From 7e40191ffcd5e04209664a3408f537c58bdde934 Mon Sep 17 00:00:00 2001 From: Kevin Quinn Date: Wed, 3 Jul 2024 14:01:09 -0400 Subject: [PATCH 01/16] random elections and spatial generation --- src/votekit/ballot_generator.py | 137 ++++++++++++++++++ src/votekit/elections/__init__.py | 2 + src/votekit/elections/election_types.py | 181 ++++++++++++++++++++++++ tests/test_elections.py | 63 ++++++++- 4 files changed, 382 insertions(+), 1 deletion(-) diff --git a/src/votekit/ballot_generator.py b/src/votekit/ballot_generator.py index 801f9cb..3df56c9 100644 --- a/src/votekit/ballot_generator.py +++ b/src/votekit/ballot_generator.py @@ -1930,3 +1930,140 @@ def generate_profile( # else return the combined profiles else: return pp + + +class UniformSpatial(BallotGenerator): + """ + Uniform spatial model for ballot generation. Assumes the candidates are uniformly distributed in + d dimensional space. Voters are then distributed equivalently, and vote with + ballots based on Euclidean distance to the candidates. + + Args: + candidates (list): List of candidate strings. + + Attributes: + candidates (list): List of candidate strings. + + """ + + def generate_profile( + self, + number_of_ballots: int, + by_bloc: bool = False, + dim: int = 2, + lower: float = 0, + upper: float = 1, + seed: Optional[int] = None, + ) -> Union[PreferenceProfile, Tuple]: + """ + Args: + number_of_ballots (int): The number of ballots to generate. + by_bloc (bool): Dummy variable from parent class. + dim (int, optional): number of dimensions to use, defaults to 2d + lower (float, optional): lower bound for uniform distribution, defaults to 0 + upper (float, optional): upper bound for uniform distribution, defaults to 1 + seed (int, optional): seed for random generation + + Returns: + Union[PreferenceProfile, Tuple] + """ + + np.random.seed(seed) + candidate_position_dict = { + c: np.random.uniform(lower, upper, size=dim) for c in self.candidates + } + voter_positions = np.random.uniform(lower, upper, size=(number_of_ballots, dim)) + + ballot_pool = [] + + for vp in voter_positions: + distance_dict = { + c: np.linalg.norm(v - vp) for c, v, in candidate_position_dict.items() + } + candidate_order = sorted(distance_dict, key=distance_dict.__getitem__) + ballot_pool.append(candidate_order) + + # reset the seed + np.random.seed(None) + + return ( + self.ballot_pool_to_profile(ballot_pool, self.candidates), + candidate_position_dict, + voter_positions, + ) + + +class ClusteredSpatial(BallotGenerator): + """ + Clustered spatial model for ballot generation. + Assumes the candidates are uniformly distributed in d dimensional space. + Voters are then distributed normally around them, and vote with + ballots based on Euclidean distance to the candidates. + + Args: + candidates (list): List of candidate strings. + + Attributes: + candidates (list): List of candidate strings. + + """ + + def generate_profile_with_dict( + self, + number_of_ballots: dict, + by_bloc: bool = False, + dim: int = 2, + lower: float = 0, + upper: float = 1, + std: float = 1, + seed: Optional[int] = None, + ) -> Union[PreferenceProfile, Tuple]: + """ + Args: + number_of_ballots (dict): The number of voters attributed + to each candidate {candidate string: # voters} + by_bloc (bool): Dummy variable from parent class. + dim (int, optional): number of dimensions to use, defaults to 2d + lower (float, optional): lower bound for uniform distribution, defaults to 0 + upper (float, optional): upper bound for uniform distribution, defaults to 1 + std (float, optional): standard deviation for voters normally distributed around + candidates, defaults to 1 + seed (int, optional): seed for random generation + + Returns: + Union[PreferenceProfile, Tuple] + """ + + np.random.seed(seed) + candidate_position_dict = { + c: np.random.uniform(lower, upper, size=dim) for c in self.candidates + } + voter_positions = [] + for c in self.candidates: + voter_positions.append( + np.random.normal( + loc=candidate_position_dict[c], + scale=std, + size=(number_of_ballots[c], dim), + ) + ) + + voter_positions_array = np.vstack(voter_positions) + + ballot_pool = [] + + for vp in voter_positions_array: + distance_dict = { + c: np.linalg.norm(v - vp) for c, v, in candidate_position_dict.items() + } + candidate_order = sorted(distance_dict, key=distance_dict.__getitem__) + ballot_pool.append(candidate_order) + + # reset the seed + np.random.seed(None) + + return ( + self.ballot_pool_to_profile(ballot_pool, self.candidates), + candidate_position_dict, + voter_positions_array, + ) diff --git a/src/votekit/elections/__init__.py b/src/votekit/elections/__init__.py index 0fb3fe1..490c934 100644 --- a/src/votekit/elections/__init__.py +++ b/src/votekit/elections/__init__.py @@ -13,6 +13,8 @@ IRV, HighestScore, Cumulative, + RandomDictator, + BoostedRandomDictator, ) from .transfers import fractional_transfer, random_transfer # noqa diff --git a/src/votekit/elections/election_types.py b/src/votekit/elections/election_types.py index 66791fe..2511aa7 100644 --- a/src/votekit/elections/election_types.py +++ b/src/votekit/elections/election_types.py @@ -1,5 +1,6 @@ from fractions import Fraction import itertools as it +import random import numpy as np from typing import Callable, Optional, Union from functools import lru_cache @@ -1117,3 +1118,183 @@ def __init__( seats=seats, tiebreak=tiebreak, ) + + +class RandomDictator(Election): + """ + Choose a winner randomly from the distribution of first place votes. For multi-winner elections + repeat this process for every winner, removing that candidate from every voter's ballot + once they have been elected + + Args: + profile (PreferenceProfile): PreferenceProfile to run election on + seats (int): number of seats to select + + Attributes: + _profile (PreferenceProfile): PreferenceProfile to run election on + seats (int): Number of seats to be elected. + + """ + + def __init__(self, profile: PreferenceProfile, seats: int): + # the super method says call the Election class + super().__init__(profile, ballot_ties=False) + self.seats = seats + + def next_round(self) -> bool: + """ + Determines if another round is needed. + + Returns: + True if number of seats has not been met, False otherwise + """ + cands_elected = 0 + for s in self.state.winners(): + cands_elected += len(s) + return cands_elected < self.seats + + def run_step(self): + if self.next_round(): + remaining = self.state.profile.get_candidates() + + ballots = self.state.profile.ballots + weights = [b.weight for b in ballots] + random_ballot = random.choices( + self.state.profile.ballots, weights=weights, k=1 + )[0] + + # randomly choose a winner from the first place rankings + winning_candidate = list(random_ballot.ranking[0])[0] + + # some formatting to make it compatible with ElectionState, which + # requires a list of sets of strings + elected = [{winning_candidate}] + + # remove the winner from the ballots + # Does this move second place votes up to first place? + new_ballots = remove_cand(winning_candidate, self.state.profile.ballots) + new_profile = PreferenceProfile(ballots=new_ballots) + + # determine who remains + remaining = [{c} for c in remaining if c != winning_candidate] + + # update for the next round + self.state = ElectionState( + curr_round=self.state.curr_round + 1, + elected=elected, + eliminated_cands=[], + remaining=remaining, + profile=new_profile, + previous=self.state, + ) + + # if this is the last round, move remaining to eliminated + if not self.next_round(): + self.state = ElectionState( + curr_round=self.state.curr_round, + elected=elected, + eliminated_cands=remaining, + remaining=[], + profile=new_profile, + previous=self.state.previous, + ) + return self.state + + def run_election(self): + # run steps until we elect the required number of candidates + while self.next_round(): + self.run_step() + + return self.state + + +class BoostedRandomDictator(RandomDictator): + """ + Modified random dictator where we + - Choose a winner randomly from the distribution of first + place votes with probability (1 - 1/(# Candidates - 1)) + - Choose a winner via a proportional to squares rule with + probability 1/(# of Candidates - 1) + + For multi-winner elections + repeat this process for every winner, removing that candidate from every voter's ballot + once they have been elected + + Args: + profile (PreferenceProfile): PreferenceProfile to run election on + seats (int): number of seats to select + + Attributes: + _profile (PreferenceProfile): PreferenceProfile to run election on + seats (int): Number of seats to be elected. + + """ + + def __init__(self, profile: PreferenceProfile, seats: int): + # the super method says call the Election class + # ballot_ties = True means it will resolve any ties in our ballots + super().__init__(profile, seats) + + def run_step(self): + if self.next_round(): + remaining = self.state.profile.get_candidates() + u = random.uniform(0, 1) + + if len(remaining) == 1: + winning_candidate = remaining[0] + + elif u <= 1 / (len(remaining) - 1): + # Choose via proportional to squares + candidate_votes = {c: 0 for c in remaining} + for ballot in self.state.profile.get_ballots(): + top_choice = list(ballot.ranking[0])[0] + candidate_votes[top_choice] += float(ballot.weight) + + squares = np.array( + [(i / len(remaining)) ** 2 for i in candidate_votes.values()] + ) + sum_of_squares = np.sum(squares) + probabilities = squares / sum_of_squares + winning_candidate = np.random.choice(remaining, p=probabilities) + + else: + ballots = self.state.profile.ballots + weights = [b.weight for b in ballots] + random_ballot = random.choices( + self.state.profile.ballots, weights=weights, k=1 + )[0] + # randomly choose a winner according to first place rankings + winning_candidate = list(random_ballot.ranking[0])[0] + + # some formatting to make it compatible with ElectionState, which + # requires a list of sets of strings + elected = [{winning_candidate}] + + # remove the winner from the ballots + new_ballots = remove_cand(winning_candidate, self.state.profile.ballots) + new_profile = PreferenceProfile(ballots=new_ballots) + + # determine who remains + remaining = [{c} for c in remaining if c != winning_candidate] + + # update for the next round + self.state = ElectionState( + curr_round=self.state.curr_round + 1, + elected=elected, + eliminated_cands=[], + remaining=remaining, + profile=new_profile, + previous=self.state, + ) + + # if this is the last round, move remaining to eliminated + if not self.next_round(): + self.state = ElectionState( + curr_round=self.state.curr_round, + elected=elected, + eliminated_cands=remaining, + remaining=[], + profile=new_profile, + previous=self.state.previous, + ) + return self.state diff --git a/tests/test_elections.py b/tests/test_elections.py index a916e3a..e2af5c5 100644 --- a/tests/test_elections.py +++ b/tests/test_elections.py @@ -1,10 +1,17 @@ from fractions import Fraction from pathlib import Path import pytest +import random +import numpy as np from votekit.ballot import Ballot from votekit.cvr_loaders import load_scottish, load_csv # type:ignore -from votekit.elections.election_types import STV, SequentialRCV +from votekit.elections.election_types import ( + STV, + SequentialRCV, + RandomDictator, + BoostedRandomDictator, +) from votekit.elections.transfers import fractional_transfer, random_transfer from votekit.pref_profile import PreferenceProfile from votekit.utils import ( @@ -184,3 +191,57 @@ def test_toy_rcv(): seq_RCV = SequentialRCV(profile=toy_pp, seats=2, ballot_ties=False) toy_winners = seq_RCV.run_election().winners() assert known_winners == toy_winners + + +def test_random_dictator(): + # set seed for more predictable results + random.seed(919717) + + # simple 3 candidate election + candidates = ["A", "B", "C"] + ballots = [ + Ballot(ranking=[{"A"}, {"B"}, {"C"}], weight=3), + Ballot(ranking=[{"B"}, {"A"}, {"C"}]), + Ballot(ranking=[{"C"}, {"B"}, {"A"}]), + ] + test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) + + # count the number of wins over a set of trials + winner_counts = {c: 0 for c in candidates} + trials = 10000 + for t in range(trials): + election = RandomDictator(test_profile, 1) + election.run_election() + winner = list(election.state.winners()[0])[0] + winner_counts[winner] += 1 + + # check to make sure that the fraction of wins matches the true probability + assert np.allclose(3 / 5, winner_counts["A"] / trials, atol=1e-2) + + +def test_boosted_random_dictator(): + # set seed for more predictable results + random.seed(919717) + + # simple 3 candidate election + candidates = ["A", "B", "C"] + ballots = [ + Ballot(ranking=[{"A"}, {"B"}, {"C"}], weight=3), + Ballot(ranking=[{"B"}, {"A"}, {"C"}]), + Ballot(ranking=[{"C"}, {"B"}, {"A"}]), + ] + test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) + + # count the number of wins over a set of trials + winner_counts = {c: 0 for c in candidates} + trials = 10000 + for t in range(trials): + election = BoostedRandomDictator(test_profile, 1) + election.run_election() + winner = list(election.state.winners()[0])[0] + winner_counts[winner] += 1 + + # check to make sure that the fraction of wins matches the true probability + assert np.allclose( + 1 / 2 * 3 / 5 + 1 / 2 * 9 / 11, winner_counts["A"] / trials, atol=1e-2 + ) From b9778a43ba6cb006cfb8ac27287d7e6ce291b036 Mon Sep 17 00:00:00 2001 From: Kevin Quinn Date: Fri, 19 Jul 2024 17:06:29 -0400 Subject: [PATCH 02/16] refactoring --- src/votekit/ballot_generator.py | 203 +++++++++++++++++------- src/votekit/elections/election_types.py | 68 ++++---- 2 files changed, 185 insertions(+), 86 deletions(-) diff --git a/src/votekit/ballot_generator.py b/src/votekit/ballot_generator.py index 3df56c9..9ea4a28 100644 --- a/src/votekit/ballot_generator.py +++ b/src/votekit/ballot_generator.py @@ -8,7 +8,7 @@ import pickle import random import warnings -from typing import Optional, Union, Tuple +from typing import Optional, Union, Tuple, Callable, Dict import apportionment.methods as apportion # type: ignore from .ballot import Ballot @@ -1932,53 +1932,102 @@ def generate_profile( return pp -class UniformSpatial(BallotGenerator): +# Not sure where to put this! Poetry complains if I try to put it inside the class +def euclidean_distance(point1: np.ndarray, point2: np.ndarray) -> float: + return float(np.linalg.norm(point1 - point2)) + + +class DSpatial(BallotGenerator): """ - Uniform spatial model for ballot generation. Assumes the candidates are uniformly distributed in - d dimensional space. Voters are then distributed equivalently, and vote with - ballots based on Euclidean distance to the candidates. + Spatial model for ballot generation. In some metric space determined + by an input distance function, randomly sample each voter's and + each candidate's positions from input voter and candidate distributions. + Using generate_profile() outputs a ranked profile which is consistent + with the sampled positions (respects distances). Args: - candidates (list): List of candidate strings. - + candidates (list[str]): List of candidate strings. + voter_dist (Callable[..., np.ndarray]): Distribution to sample a single + voter's position from, defaults to uniform distribution. + voter_params: (dict[str, float], optional): Parameters to be passed to + voter_dist, defaults to uniform(0,1) in 2 dimensions. + candidate_dist: (Callable[..., np.ndarray]): Distribution to sample a + single candidate's position from, defaults to uniform distribution. + candidate_params: Optional[Dict[str, float]]: Parameters to be passed + to candidate_dist, defaults to uniform(0,1) in 2 dimensions. + distance: (Callable[[np.ndarray, np.ndarray], float]], optional): + Computes distance between a voter and a candidate, + defaults to euclidean distance. Attributes: - candidates (list): List of candidate strings. + candidates (list[str]): List of candidate strings. + voter_dist (Callable[..., np.ndarray]): Distribution to sample a single + voter's position from, defaults to uniform distribution. + voter_params: (dict[str, float], optional): Parameters to be passed to + voter_dist, defaults to uniform(0,1) in 2 dimensions. + candidate_dist: (Callable[..., np.ndarray]): Distribution to sample a + single candidate's position from, defaults to uniform distribution. + candidate_params: Optional[Dict[str, float]]: Parameters to be passed + to candidate_dist, defaults to uniform(0,1) in 2 dimensions. + distance: (Callable[[np.ndarray, np.ndarray], float]], optional): + Computes distance between a voter and a candidate, + defaults to euclidean distance. """ - def generate_profile( + def __init__( self, - number_of_ballots: int, - by_bloc: bool = False, - dim: int = 2, - lower: float = 0, - upper: float = 1, - seed: Optional[int] = None, + candidates: list[str], + voter_dist: Callable[..., np.ndarray] = np.random.uniform, + voter_params: Optional[Dict[str, float]] = None, + candidate_dist: Callable[..., np.ndarray] = np.random.uniform, + candidate_params: Optional[Dict[str, float]] = None, + distance: Callable[[np.ndarray, np.ndarray], float] = euclidean_distance, + ): + super().__init__(candidates=candidates) + self.voter_dist = voter_dist + self.candidate_dist = candidate_dist + + if voter_params is None: + # default params used for np.random.uniform + self.voter_params = {"low": 0.0, "high": 1.0, "size": 2.0} + else: + self.voter_params = voter_params + + if candidate_params is None: + # default params used for np.random.uniform + self.candidate_params = {"low": 0.0, "high": 1.0, "size": 2.0} + else: + self.candidate_params = candidate_params + + self.distance = distance + + def generate_profile( + self, number_of_ballots: int, by_bloc: bool = False, seed: Optional[int] = None ) -> Union[PreferenceProfile, Tuple]: """ Args: number_of_ballots (int): The number of ballots to generate. by_bloc (bool): Dummy variable from parent class. - dim (int, optional): number of dimensions to use, defaults to 2d - lower (float, optional): lower bound for uniform distribution, defaults to 0 - upper (float, optional): upper bound for uniform distribution, defaults to 1 - seed (int, optional): seed for random generation + seed (int, optional): Seed for random generation, defaults to None + which resets the random seed. Returns: - Union[PreferenceProfile, Tuple] + preference profile, candidate positions, voter positions: + (Union[PreferenceProfile, Tuple]) """ np.random.seed(seed) candidate_position_dict = { - c: np.random.uniform(lower, upper, size=dim) for c in self.candidates + c: self.candidate_dist(**self.candidate_params) for c in self.candidates } - voter_positions = np.random.uniform(lower, upper, size=(number_of_ballots, dim)) + voter_positions = np.array( + [self.voter_dist(**self.voter_params) for v in range(number_of_ballots)] + ) ballot_pool = [] - - for vp in voter_positions: + for v in voter_positions: distance_dict = { - c: np.linalg.norm(v - vp) for c, v, in candidate_position_dict.items() + i: self.distance(v, c) for i, c, in candidate_position_dict.items() } candidate_order = sorted(distance_dict, key=distance_dict.__getitem__) ballot_pool.append(candidate_order) @@ -1993,68 +2042,106 @@ def generate_profile( ) -class ClusteredSpatial(BallotGenerator): +class Clustered_DSpatial(BallotGenerator): """ - Clustered spatial model for ballot generation. - Assumes the candidates are uniformly distributed in d dimensional space. - Voters are then distributed normally around them, and vote with - ballots based on Euclidean distance to the candidates. + Clustered spatial model for ballot generation. In some metric space + determined by an input distance function, randomly sample + each candidate's positions from input candidate distribution. Then + sample voters's positions from normal distributions centered around each + of the candidate's positions. Using generate_profile() + outputs a ranked profile which is consistent + with the sampled positions (respects distances). Args: - candidates (list): List of candidate strings. - + candidates (list[str]): List of candidate strings. + voter_dist (Callable[..., np.ndarray]): Distribution to sample a single + voter's position from, defaults to uniform distribution. + voter_params: (dict[str, float], optional): Parameters to be passed to + voter_dist, defaults to uniform(0,1) in 2 dimensions. + candidate_dist: (Callable[..., np.ndarray]): Distribution to sample a + single candidate's position from, defaults to uniform distribution. + candidate_params: Optional[Dict[str, float]]: Parameters to be passed + to candidate_dist, defaults to uniform(0,1) in 2 dimensions. + distance: (Callable[[np.ndarray, np.ndarray], float]], optional): + Computes distance between a voter and a candidate, + defaults to euclidean distance. Attributes: - candidates (list): List of candidate strings. + candidates (list[str]): List of candidate strings. + voter_dist (Callable[..., np.ndarray]): Distribution to sample a single + voter's position from, defaults to uniform distribution. + voter_params: (dict[str, float], optional): Parameters to be passed to + voter_dist, defaults to uniform(0,1) in 2 dimensions. + candidate_dist: (Callable[..., np.ndarray]): Distribution to sample a + single candidate's position from, defaults to uniform distribution. + candidate_params: Optional[Dict[str, float]]: Parameters to be passed + to candidate_dist, defaults to uniform(0,1) in 2 dimensions. + distance: (Callable[[np.ndarray, np.ndarray], float]], optional): + Computes distance between a voter and a candidate, + defaults to euclidean distance. """ - def generate_profile_with_dict( + def __init__( self, - number_of_ballots: dict, - by_bloc: bool = False, - dim: int = 2, - lower: float = 0, - upper: float = 1, - std: float = 1, - seed: Optional[int] = None, + candidates: list[str], + voter_dist: Callable[..., np.ndarray] = np.random.uniform, + voter_params: Optional[Dict[str, np.ndarray]] = None, + candidate_dist: Callable[..., np.ndarray] = np.random.uniform, + candidate_params: Optional[Dict[str, float]] = None, + distance: Callable[[np.ndarray, np.ndarray], float] = euclidean_distance, + ): + super().__init__(candidates=candidates) + self.candidate_dist = candidate_dist + + if voter_params is None: + # default params used for np.random.normal + self.voter_params = {"std": np.array(1.0), "size": np.array(2.0)} + else: + self.voter_params = voter_params + + if candidate_params is None: + # default params used for np.random.uniform + self.candidate_params = {"low": 0.0, "high": 1.0, "size": 2.0} + else: + self.candidate_params = candidate_params + + self.distance = distance + + def generate_profile_with_dict( + self, number_of_ballots: dict, by_bloc: bool = False, seed: Optional[int] = None ) -> Union[PreferenceProfile, Tuple]: """ Args: number_of_ballots (dict): The number of voters attributed to each candidate {candidate string: # voters} by_bloc (bool): Dummy variable from parent class. - dim (int, optional): number of dimensions to use, defaults to 2d - lower (float, optional): lower bound for uniform distribution, defaults to 0 - upper (float, optional): upper bound for uniform distribution, defaults to 1 - std (float, optional): standard deviation for voters normally distributed around - candidates, defaults to 1 - seed (int, optional): seed for random generation + seed (int, optional): Seed for random generation, defaults to None + which resets the random seed. Returns: - Union[PreferenceProfile, Tuple] + preference profile, candidate positions, voter positions: + (Union[PreferenceProfile, Tuple]) """ np.random.seed(seed) candidate_position_dict = { - c: np.random.uniform(lower, upper, size=dim) for c in self.candidates + c: self.candidate_dist(**self.candidate_params) for c in self.candidates } voter_positions = [] for c in self.candidates: - voter_positions.append( - np.random.normal( - loc=candidate_position_dict[c], - scale=std, - size=(number_of_ballots[c], dim), + for v in range(number_of_ballots[c]): + voter_positions.append( + np.random.normal( + loc=candidate_position_dict[c], **self.voter_params + ) ) - ) voter_positions_array = np.vstack(voter_positions) ballot_pool = [] - - for vp in voter_positions_array: + for vp in voter_positions: distance_dict = { - c: np.linalg.norm(v - vp) for c, v, in candidate_position_dict.items() + i: self.distance(vp, c) for i, c, in candidate_position_dict.items() } candidate_order = sorted(distance_dict, key=distance_dict.__getitem__) ballot_pool.append(candidate_order) diff --git a/src/votekit/elections/election_types.py b/src/votekit/elections/election_types.py index 2511aa7..f29b1a8 100644 --- a/src/votekit/elections/election_types.py +++ b/src/votekit/elections/election_types.py @@ -1124,20 +1124,19 @@ class RandomDictator(Election): """ Choose a winner randomly from the distribution of first place votes. For multi-winner elections repeat this process for every winner, removing that candidate from every voter's ballot - once they have been elected + once they have been elected. Args: - profile (PreferenceProfile): PreferenceProfile to run election on - seats (int): number of seats to select + profile (PreferenceProfile): PreferenceProfile to run election on. + seats (int): Number of seats to elect. Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on + _profile (PreferenceProfile): PreferenceProfile to run election on. seats (int): Number of seats to be elected. """ def __init__(self, profile: PreferenceProfile, seats: int): - # the super method says call the Election class super().__init__(profile, ballot_ties=False) self.seats = seats @@ -1146,12 +1145,10 @@ def next_round(self) -> bool: Determines if another round is needed. Returns: - True if number of seats has not been met, False otherwise + (bool) True if number of seats has not been met, False otherwise. """ - cands_elected = 0 - for s in self.state.winners(): - cands_elected += len(s) - return cands_elected < self.seats + cands_elected = [len(s) for s in self.state.winners()] + return sum(cands_elected) < self.seats def run_step(self): if self.next_round(): @@ -1164,14 +1161,13 @@ def run_step(self): )[0] # randomly choose a winner from the first place rankings - winning_candidate = list(random_ballot.ranking[0])[0] + winning_candidate = random.choice(list(random_ballot.ranking[0])) # some formatting to make it compatible with ElectionState, which # requires a list of sets of strings elected = [{winning_candidate}] # remove the winner from the ballots - # Does this move second place votes up to first place? new_ballots = remove_cand(winning_candidate, self.state.profile.ballots) new_profile = PreferenceProfile(ballots=new_ballots) @@ -1208,32 +1204,41 @@ def run_election(self): return self.state -class BoostedRandomDictator(RandomDictator): +class BoostedRandomDictator(Election): """ - Modified random dictator where we - - Choose a winner randomly from the distribution of first - place votes with probability (1 - 1/(# Candidates - 1)) - - Choose a winner via a proportional to squares rule with - probability 1/(# of Candidates - 1) + Modified random dictator where + - With probability (1 - 1/(# Candidates - 1)) + choose a winner randomly from the distribution of first place votes. + - With probability 1/(# of Candidates - 1) + Choose a winner via a proportional to squares rule. For multi-winner elections - repeat this process for every winner, removing that candidate from every voter's ballot - once they have been elected + repeat this process for every winner, removing that candidate from every + voter's ballot once they have been elected. Args: - profile (PreferenceProfile): PreferenceProfile to run election on - seats (int): number of seats to select + profile (PreferenceProfile): PreferenceProfile to run election on. + seats (int): Number of seats to elect. Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on + _profile (PreferenceProfile): PreferenceProfile to run election on. seats (int): Number of seats to be elected. """ def __init__(self, profile: PreferenceProfile, seats: int): - # the super method says call the Election class - # ballot_ties = True means it will resolve any ties in our ballots - super().__init__(profile, seats) + super().__init__(profile, ballot_ties=False) + self.seats = seats + + def next_round(self) -> bool: + """ + Determines if another round is needed. + + Returns: + (bool) True if number of seats has not been met, False otherwise. + """ + cands_elected = [len(s) for s in self.state.winners()] + return sum(cands_elected) < self.seats def run_step(self): if self.next_round(): @@ -1247,7 +1252,7 @@ def run_step(self): # Choose via proportional to squares candidate_votes = {c: 0 for c in remaining} for ballot in self.state.profile.get_ballots(): - top_choice = list(ballot.ranking[0])[0] + top_choice = random.choice(list(ballot.ranking[0])) candidate_votes[top_choice] += float(ballot.weight) squares = np.array( @@ -1264,7 +1269,7 @@ def run_step(self): self.state.profile.ballots, weights=weights, k=1 )[0] # randomly choose a winner according to first place rankings - winning_candidate = list(random_ballot.ranking[0])[0] + winning_candidate = random.choice(list(random_ballot.ranking[0])) # some formatting to make it compatible with ElectionState, which # requires a list of sets of strings @@ -1298,3 +1303,10 @@ def run_step(self): previous=self.state.previous, ) return self.state + + def run_election(self): + # run steps until we elect the required number of candidates + while self.next_round(): + self.run_step() + + return self.state From 8ee67bcc833213ddbee113eaa4e8ac2172e986cf Mon Sep 17 00:00:00 2001 From: Kevin Quinn Date: Fri, 2 Aug 2024 17:00:44 -0400 Subject: [PATCH 03/16] Plurality Veto + cleaning up --- src/votekit/ballot_generator.py | 135 +++++++++++++----------- src/votekit/elections/__init__.py | 1 + src/votekit/elections/election_types.py | 124 ++++++++++++++++++++++ src/votekit/metrics/__init__.py | 2 +- src/votekit/metrics/distances.py | 4 + tests/test_elections.py | 31 ++++++ 6 files changed, 234 insertions(+), 63 deletions(-) diff --git a/src/votekit/ballot_generator.py b/src/votekit/ballot_generator.py index 9ea4a28..d40ffde 100644 --- a/src/votekit/ballot_generator.py +++ b/src/votekit/ballot_generator.py @@ -8,12 +8,13 @@ import pickle import random import warnings -from typing import Optional, Union, Tuple, Callable, Dict +from typing import Optional, Union, Tuple, Callable, Dict, Any import apportionment.methods as apportion # type: ignore from .ballot import Ballot from .pref_profile import PreferenceProfile from .pref_interval import combine_preference_intervals, PreferenceInterval +from votekit.metrics import euclidean_dist def sample_cohesion_ballot_types( @@ -1932,11 +1933,6 @@ def generate_profile( return pp -# Not sure where to put this! Poetry complains if I try to put it inside the class -def euclidean_distance(point1: np.ndarray, point2: np.ndarray) -> float: - return float(np.linalg.norm(point1 - point2)) - - class DSpatial(BallotGenerator): """ Spatial model for ballot generation. In some metric space determined @@ -1947,41 +1943,42 @@ class DSpatial(BallotGenerator): Args: candidates (list[str]): List of candidate strings. - voter_dist (Callable[..., np.ndarray]): Distribution to sample a single - voter's position from, defaults to uniform distribution. - voter_params: (dict[str, float], optional): Parameters to be passed to - voter_dist, defaults to uniform(0,1) in 2 dimensions. - candidate_dist: (Callable[..., np.ndarray]): Distribution to sample a - single candidate's position from, defaults to uniform distribution. - candidate_params: Optional[Dict[str, float]]: Parameters to be passed - to candidate_dist, defaults to uniform(0,1) in 2 dimensions. + voter_dist (Callable[..., np.ndarray], optional): Distribution to sample a single + voter's position from, defaults to uniform distribution. + voter_params: (Optional[Dict[str, Any]], optional): Parameters to be passed to + voter_dist, defaults to None, which creates the unif(0,1) distribution in 2 dimensions. + candidate_dist: (Callable[..., np.ndarray], optional): Distribution to sample a + single candidate's position from, defaults to uniform distribution. + candidate_params: (Optional[Dict[str, Any]], optional): Parameters to be passed + to candidate_dist, defaults to None, which creates the unif(0,1) + distribution in 2 dimensions. distance: (Callable[[np.ndarray, np.ndarray], float]], optional): - Computes distance between a voter and a candidate, - defaults to euclidean distance. + Computes distance between a voter and a candidate, + defaults to euclidean distance. Attributes: candidates (list[str]): List of candidate strings. - voter_dist (Callable[..., np.ndarray]): Distribution to sample a single - voter's position from, defaults to uniform distribution. - voter_params: (dict[str, float], optional): Parameters to be passed to - voter_dist, defaults to uniform(0,1) in 2 dimensions. - candidate_dist: (Callable[..., np.ndarray]): Distribution to sample a - single candidate's position from, defaults to uniform distribution. - candidate_params: Optional[Dict[str, float]]: Parameters to be passed - to candidate_dist, defaults to uniform(0,1) in 2 dimensions. + voter_dist (Callable[..., np.ndarray], optional): Distribution to sample a single + voter's position from, defaults to uniform distribution. + voter_params: (Optional[Dict[str, Any]], optional): Parameters to be passed to + voter_dist, defaults to None, which creates the unif(0,1) distribution in 2 dimensions. + candidate_dist: (Callable[..., np.ndarray], optional): Distribution to sample a + single candidate's position from, defaults to uniform distribution. + candidate_params: (Optional[Dict[str, Any]], optional): Parameters to be passed + to candidate_dist, defaults to None, which creates the unif(0,1) + distribution in 2 dimensions. distance: (Callable[[np.ndarray, np.ndarray], float]], optional): - Computes distance between a voter and a candidate, - defaults to euclidean distance. - + Computes distance between a voter and a candidate, + defaults to euclidean distance. """ def __init__( self, candidates: list[str], voter_dist: Callable[..., np.ndarray] = np.random.uniform, - voter_params: Optional[Dict[str, float]] = None, + voter_params: Optional[Dict[str, Any]] = None, candidate_dist: Callable[..., np.ndarray] = np.random.uniform, - candidate_params: Optional[Dict[str, float]] = None, - distance: Callable[[np.ndarray, np.ndarray], float] = euclidean_distance, + candidate_params: Optional[Dict[str, Any]] = None, + distance: Callable[[np.ndarray, np.ndarray], float] = euclidean_dist, ): super().__init__(candidates=candidates) self.voter_dist = voter_dist @@ -2012,8 +2009,14 @@ def generate_profile( which resets the random seed. Returns: - preference profile, candidate positions, voter positions: - (Union[PreferenceProfile, Tuple]) + (Union[PreferenceProfile, Tuple]): + preference profile (Preference Profile), + candidate positions (dict[str, np.ndarray), + voter positions (np.ndarray): + A tuple containing the preference profile object, + a dictionary with each candidate's position in the metric + space, and a matrix where each row is a single voter's position + in the metric space. """ np.random.seed(seed) @@ -2054,41 +2057,42 @@ class Clustered_DSpatial(BallotGenerator): Args: candidates (list[str]): List of candidate strings. - voter_dist (Callable[..., np.ndarray]): Distribution to sample a single - voter's position from, defaults to uniform distribution. - voter_params: (dict[str, float], optional): Parameters to be passed to - voter_dist, defaults to uniform(0,1) in 2 dimensions. - candidate_dist: (Callable[..., np.ndarray]): Distribution to sample a - single candidate's position from, defaults to uniform distribution. - candidate_params: Optional[Dict[str, float]]: Parameters to be passed - to candidate_dist, defaults to uniform(0,1) in 2 dimensions. + voter_dist (Callable[..., np.ndarray], optional): Distribution to sample a single + voter's position from, defaults to uniform distribution. + voter_params: (Optional[dict[str, Any]], optional): Parameters to be passed to + voter_dist, defaults to None, which creates the unif(0,1) distribution in 2 dimensions. + candidate_dist: (Callable[..., np.ndarray], optional): Distribution to sample a + single candidate's position from, defaults to uniform distribution. + candidate_params: (Optional[Dict[str, float]], optional): Parameters to be passed + to candidate_dist, defaults None which creates the unif(0,1) + distribution in 2 dimensions. distance: (Callable[[np.ndarray, np.ndarray], float]], optional): - Computes distance between a voter and a candidate, - defaults to euclidean distance. + Computes distance between a voter and a candidate, + defaults to euclidean distance. Attributes: candidates (list[str]): List of candidate strings. - voter_dist (Callable[..., np.ndarray]): Distribution to sample a single - voter's position from, defaults to uniform distribution. - voter_params: (dict[str, float], optional): Parameters to be passed to - voter_dist, defaults to uniform(0,1) in 2 dimensions. - candidate_dist: (Callable[..., np.ndarray]): Distribution to sample a - single candidate's position from, defaults to uniform distribution. - candidate_params: Optional[Dict[str, float]]: Parameters to be passed - to candidate_dist, defaults to uniform(0,1) in 2 dimensions. + voter_dist (Callable[..., np.ndarray], optional): Distribution to sample a single + voter's position from, defaults to uniform distribution. + voter_params: (Optional[dict[str, Any]], optional): Parameters to be passed to + voter_dist, defaults to None, which creates the unif(0,1) distribution in 2 dimensions. + candidate_dist: (Callable[..., np.ndarray], optional): Distribution to sample a + single candidate's position from, defaults to uniform distribution. + candidate_params: (Optional[Dict[str, float]], optional): Parameters to be passed + to candidate_dist, defaults None which creates the unif(0,1) + distribution in 2 dimensions. distance: (Callable[[np.ndarray, np.ndarray], float]], optional): - Computes distance between a voter and a candidate, - defaults to euclidean distance. - + Computes distance between a voter and a candidate, + defaults to euclidean distance. """ def __init__( self, candidates: list[str], voter_dist: Callable[..., np.ndarray] = np.random.uniform, - voter_params: Optional[Dict[str, np.ndarray]] = None, + voter_params: Optional[Dict[str, Any]] = None, candidate_dist: Callable[..., np.ndarray] = np.random.uniform, - candidate_params: Optional[Dict[str, float]] = None, - distance: Callable[[np.ndarray, np.ndarray], float] = euclidean_distance, + candidate_params: Optional[Dict[str, Any]] = None, + distance: Callable[[np.ndarray, np.ndarray], float] = euclidean_dist, ): super().__init__(candidates=candidates) self.candidate_dist = candidate_dist @@ -2112,15 +2116,21 @@ def generate_profile_with_dict( ) -> Union[PreferenceProfile, Tuple]: """ Args: - number_of_ballots (dict): The number of voters attributed + number_of_ballots (dict[str, int]): The number of voters attributed to each candidate {candidate string: # voters} by_bloc (bool): Dummy variable from parent class. seed (int, optional): Seed for random generation, defaults to None - which resets the random seed. + which resets the random seed. Returns: - preference profile, candidate positions, voter positions: - (Union[PreferenceProfile, Tuple]) + (Union[PreferenceProfile, Tuple]): + preference profile (Preference Profile), + candidate positions (dict[str, np.ndarray), + voter positions (np.ndarray): + A tuple containing the preference profile object, + a dictionary with each candidate's position in the metric + space, and a matrix where each row is a single voter's position + in the metric space. """ np.random.seed(seed) @@ -2139,9 +2149,10 @@ def generate_profile_with_dict( voter_positions_array = np.vstack(voter_positions) ballot_pool = [] - for vp in voter_positions: + for v_position in voter_positions: distance_dict = { - i: self.distance(vp, c) for i, c, in candidate_position_dict.items() + c: self.distance(v_position, c_position) + for c, c_position, in candidate_position_dict.items() } candidate_order = sorted(distance_dict, key=distance_dict.__getitem__) ballot_pool.append(candidate_order) diff --git a/src/votekit/elections/__init__.py b/src/votekit/elections/__init__.py index 490c934..4003995 100644 --- a/src/votekit/elections/__init__.py +++ b/src/votekit/elections/__init__.py @@ -15,6 +15,7 @@ Cumulative, RandomDictator, BoostedRandomDictator, + PluralityVeto, ) from .transfers import fractional_transfer, random_transfer # noqa diff --git a/src/votekit/elections/election_types.py b/src/votekit/elections/election_types.py index f29b1a8..9f94652 100644 --- a/src/votekit/elections/election_types.py +++ b/src/votekit/elections/election_types.py @@ -286,6 +286,8 @@ def run_step(self) -> ElectionState: # Else we know the cutoff is in the set, we compute and randomly # select the number of candidates we can select else: + # NOTE: I think I notice a bug here! If a single candidate is named 'ABC' this + # counts three candidates 'A', 'B', and 'C' -- i.e. it breaks up strings accepted = len(list(it.chain(*ballot.ranking[:i]))) num_to_allow = self.k - accepted approvals.extend( @@ -1310,3 +1312,125 @@ def run_election(self): self.run_step() return self.state + + +class PluralityVeto(Election): + """ + Scores each candidate by their plurality (number of first) place votes, + then in a randomized order it lets each voter decrement the score of their + least favorite candidate. The candidate with the largest score at the end is + then chosen as the winner. + + Args: + profile (PreferenceProfile): PreferenceProfile to run election on. + seats (int): Number of seats to elect. + + Attributes: + _profile (PreferenceProfile): PreferenceProfile to run election on. + seats (int): Number of seats to be elected. + + """ + + def __init__(self, profile: PreferenceProfile, seats: int): + super().__init__(profile, ballot_ties=False) + self.seats = seats + + def next_round(self) -> bool: + """ + Determines if another round is needed. + + Returns: + (bool) True if number of seats has not been met, False otherwise. + """ + cands_elected = [len(s) for s in self.state.winners()] + return sum(cands_elected) < self.seats + + def run_step(self): + if self.next_round(): + candidates = self.state.profile.get_candidates() + ballots = self.state.profile.ballots + + # First, count a plurality score for each of the candidates + candidate_approvals = {c: Fraction(0) for c in candidates} + for ballot in ballots: + # From each ballot, randomly choose one candidate from the + # set of their first place ranking candidates to accept + first_choice = random.choice(list(ballot.ranking[0])) + candidate_approvals[first_choice] += ballot.weight + + # Next take a randomized ordering of the ballots: + random_order = np.random.permutation(len(ballots)) + + # Use another dictionary to keep track of which candidates have + # non-zero approval scores + A = {c: score for c, score in candidate_approvals.items() if score > 0} + + # Finally, decrement scores with vetos from each of the voters + last_eliminated = None + for r in random_order: + # From each ballot, look at all the remaining candidates + # in A, and veto one which this ballot ranks lowest. + # This might be expensive, let me know if you have any ideas for how to improve + ballot = ballots[r] + + max_rank = -1 + max_rank_cands = [] + for c in A.keys(): + for i, cand_set in enumerate(ballot.ranking): + if c in cand_set: + if i > max_rank: + max_rank = i + max_rank_cands = [c] + elif i == max_rank: + max_rank_cands.append(c) + + last_choice = random.choice(max_rank_cands) + A[last_choice] -= ballot.weight + + # if score falls below 0, eliminate that candidate + if A[last_choice] <= 0: + del A[last_choice] + last_eliminated = last_choice + + # The very last eliminated candidate is the winner + winning_candidate = last_eliminated + + # some formatting to make it compatible with ElectionState, which + # requires a list of sets of strings + elected = [{winning_candidate}] + + # remove the winner from the ballots + new_ballots = remove_cand(winning_candidate, self.state.profile.ballots) + new_profile = PreferenceProfile(ballots=new_ballots) + + # determine who remains + remaining = [{c} for c in candidates if c != winning_candidate] + + # update for the next round + self.state = ElectionState( + curr_round=self.state.curr_round + 1, + elected=elected, + eliminated_cands=[], + remaining=remaining, + profile=new_profile, + previous=self.state, + ) + + # if this is the last round, move remaining to eliminated + if not self.next_round(): + self.state = ElectionState( + curr_round=self.state.curr_round, + elected=elected, + eliminated_cands=remaining, + remaining=[], + profile=new_profile, + previous=self.state.previous, + ) + return self.state + + def run_election(self): + # run steps until we elect the required number of candidates + while self.next_round(): + self.run_step() + + return self.state diff --git a/src/votekit/metrics/__init__.py b/src/votekit/metrics/__init__.py index 30542f0..e2c972a 100644 --- a/src/votekit/metrics/__init__.py +++ b/src/votekit/metrics/__init__.py @@ -1 +1 @@ -from .distances import earth_mover_dist, lp_dist, em_array # noqa +from .distances import earth_mover_dist, lp_dist, em_array, euclidean_dist # noqa diff --git a/src/votekit/metrics/distances.py b/src/votekit/metrics/distances.py index dd081b2..367a0a0 100644 --- a/src/votekit/metrics/distances.py +++ b/src/votekit/metrics/distances.py @@ -145,3 +145,7 @@ def em_array(pp: PreferenceProfile) -> list: ] return elect_distr + + +def euclidean_dist(point1: np.ndarray, point2: np.ndarray) -> float: + return float(np.linalg.norm(point1 - point2)) diff --git a/tests/test_elections.py b/tests/test_elections.py index e2af5c5..216cb95 100644 --- a/tests/test_elections.py +++ b/tests/test_elections.py @@ -11,6 +11,7 @@ SequentialRCV, RandomDictator, BoostedRandomDictator, + PluralityVeto, ) from votekit.elections.transfers import fractional_transfer, random_transfer from votekit.pref_profile import PreferenceProfile @@ -245,3 +246,33 @@ def test_boosted_random_dictator(): assert np.allclose( 1 / 2 * 3 / 5 + 1 / 2 * 9 / 11, winner_counts["A"] / trials, atol=1e-2 ) + + +def test_plurality_veto(): + random.seed(919717) + + # simple 3 candidate election + candidates = ["A", "B", "C"] + # With every possible permutation of candidates, we should + # see that each candidate wins with probability 1/3 + ballots = [ + Ballot(ranking=[{"A"}, {"B"}, {"C"}]), + Ballot(ranking=[{"A"}, {"C"}, {"B"}]), + Ballot(ranking=[{"B"}, {"A"}, {"C"}]), + Ballot(ranking=[{"B"}, {"C"}, {"A"}]), + Ballot(ranking=[{"C"}, {"B"}, {"A"}]), + Ballot(ranking=[{"C"}, {"A"}, {"B"}]), + ] + test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) + + # count the number of wins over a set of trials + winner_counts = {c: 0 for c in candidates} + trials = 10000 + for t in range(trials): + election = PluralityVeto(test_profile, 1) + election.run_election() + winner = list(election.state.winners()[0])[0] + winner_counts[winner] += 1 + + # check to make sure that the fraction of wins matches the true probability + assert np.allclose(1 / 3, winner_counts["A"] / trials, atol=1e-2) From 929642008c99a8e28bfd1bc1c35f4fb924ce5e5c Mon Sep 17 00:00:00 2001 From: Kevin Quinn Date: Mon, 5 Aug 2024 15:12:33 -0400 Subject: [PATCH 04/16] fixed clustered DSpatial and added some examples --- notebooks/6_metric_voting.ipynb | 1052 +++++++++++++++++++++++++++++++ src/votekit/ballot_generator.py | 27 +- 2 files changed, 1069 insertions(+), 10 deletions(-) create mode 100755 notebooks/6_metric_voting.ipynb diff --git a/notebooks/6_metric_voting.ipynb b/notebooks/6_metric_voting.ipynb new file mode 100755 index 0000000..b3d2e40 --- /dev/null +++ b/notebooks/6_metric_voting.ipynb @@ -0,0 +1,1052 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "236d74c2-1d8a-4a83-aaa3-85c202263fa1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\kq146\\AppData\\Roaming\\Python\\Python39\\site-packages\\networkx\\utils\\backends.py:135: RuntimeWarning: networkx backend defined more than once: nx-loopback\n", + " backends.update(_get_backends(\"networkx.backends\"))\n" + ] + } + ], + "source": [ + "import sys\n", + "import os\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import random\n", + "import seaborn as sns\n", + "import itertools as it\n", + "\n", + "from votekit.pref_profile import PreferenceProfile\n", + "from votekit.ballot import Ballot\n", + "from votekit.ballot_generator import DSpatial\n", + "from votekit.ballot_generator import Clustered_DSpatial\n", + "from votekit.elections import SNTV, STV, Borda, RandomDictator, BoostedRandomDictator, PluralityVeto, fractional_transfer" + ] + }, + { + "cell_type": "markdown", + "id": "d9da4e50-f7fb-40e1-a815-fc00f94a943b", + "metadata": {}, + "source": [ + "# Metric Ballot Generation" + ] + }, + { + "cell_type": "markdown", + "id": "6baeffdb-ef19-4335-9412-7daafdc52ee6", + "metadata": {}, + "source": [ + "Here we show some examples from a setting where voters and candidates occupy random positions in a metric space. \n", + "With voters metric positions drawn from a distribution $D_V$, candidates metric positions drawn from a distribution $D_C$, \n", + "and a distance function $d: V \\times C \\rightarrow \\mathbb{R}$, we generate ballots by sampling from $D_V$, $D_C$ and \n", + "then create ballots by ranking the candidates by distance to each voter." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ecb46810-4921-4335-8281-bf224d713ff6", + "metadata": {}, + "outputs": [], + "source": [ + "# Choose number of voters n\n", + "# And the number of candidates m\n", + "n = 100\n", + "m = 25\n", + "candidates = [str(i) for i in range(m)]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f31765c0-3aa3-46c2-81b1-986e3b807ca9", + "metadata": {}, + "outputs": [], + "source": [ + "# We can use any numpy distribution (or custom distribution -- more on that later)\n", + "# to randomly sample positions for voters and canidates. \n", + "# Here we sample from the following distributions distributions\n", + "# Voters: Normal(mean = 1/2, std = 1/10) in 2d\n", + "# Candidates: Uniform(0,1) in 2d\n", + "\n", + "# Define a dictionary of parameters for both distributions\n", + "# for a full list of possible distributions and their \n", + "# required parameters check out:\n", + "# https://numpy.org/doc/1.16/reference/routines.random.html\n", + "voter_params = {'loc': 0.5, 'scale': 0.1, 'size': 2}\n", + "candidate_params = {'low': 0, 'high': 1, 'size': 2}\n", + "\n", + "# We also define a distance function to compute the \n", + "# distances between any pair of voters and candidates.\n", + "# Here, we just use euclidean distance\n", + "distance = lambda point1, point2: np.linalg.norm(point1 - point2)\n", + "\n", + "# Now we may pass all of to the DSpatial generation method\n", + "generator = DSpatial(candidates = candidates,\n", + " voter_dist = np.random.normal, voter_params = voter_params,\n", + " candidate_dist = np.random.uniform, candidate_params = candidate_params,\n", + " distance = distance)\n", + "\n", + "# Generate a profile from random candidate and voter positions\n", + "profile, candidate_position_dict, voter_positions = generator.generate_profile(number_of_ballots = n, seed = None)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f31100e9-7cf7-44ec-99fa-f7c981071aeb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAisAAAGdCAYAAADT1TPdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABH1klEQVR4nO3df3xT9b0/8FeSNumPtClt+hMrtWixMpUftXyxus2tG1cdGzonEy4UpjgdeJVuqEwBGfLjOkQcIqiblO3qxc0rbhPEYe+4m8jWieJDa8GNH4JCfwFNmhZampzvH5jYtEl6TnJ+Jq/n49E/COc0n+Sk+bzP5/P+vD8mQRAEEBEREemUWesGEBEREUXCYIWIiIh0jcEKERER6RqDFSIiItI1BitERESkawxWiIiISNcYrBAREZGuMVghIiIiXUvSugFi+Hw+HD9+HBkZGTCZTFo3h4iIiEQQBAGdnZ0oKiqC2Rz9+IghgpXjx4+juLhY62YQERFRFI4dO4YLLrgg6vMNEaxkZGQAOP9iMzMzNW4NERERieF2u1FcXBzox6NliGDFP/WTmZnJYIWIiMhgYk3hYIItERER6RqDFSIiItI1BitERESkawxWiIiISNcYrBAREZGuMVghIiIiXWOwQkRERLomOVj5y1/+gsmTJ6OoqAgmkwmvvvrqkOfs2rUL48aNg81mw8UXX4y6uroomkpERESJSHKw0tXVhSuvvBLr168Xdfzhw4dx44034rrrrsO+fftw33334Y477sAbb7whubEUfwTBh+6ORnS27kZ3RyMEwad1k4iISGckV7C9/vrrcf3114s+fuPGjbjooovw+OOPAwDKy8vx1ltv4YknnsCkSZOkPj3FEU97A9oO1sHbeyrwmMWajdyRs2B3VmrYMiIi0hPFc1b27NmD6urqoMcmTZqEPXv2hD2np6cHbrc76Ifii6e9Ac1Na4ICFQDw9p5Cc9MaeNobNGoZERHpjeLBSnNzM/Lz84Mey8/Ph9vtxpkzZ0Kes3LlSjgcjsAPd1yOL4LgQ9vBuojHtB/azCkhIiICoNPVQAsXLoTL5Qr8HDt2TOsmkYzOuJoGjagM1NdzEmdcTSq1iIiI9EzxXZcLCgrQ0tIS9FhLSwsyMzORmpoa8hybzQabzaZ000gj3t4OWY8jIqL4pvjIysSJE1FfXx/02M6dOzFx4kSln5p0ymLNkvU4IiKKb5KDFY/Hg3379mHfvn0Azi9N3rdvH44ePQrg/BTOzJkzA8ffddddOHToEO6//37s378fTz/9NH77299i/vz58rwCMpxURzks1uyIxyTZcpDqKFepRUREpGeSg5V33nkHY8eOxdixYwEAtbW1GDt2LBYvXgwAOHHiRCBwAYCLLroI27Ztw86dO3HllVfi8ccfxy9/+UsuW05gJpMZuSNnRTzGWVoDk0mXKVVERKQykyAIgtaNGIrb7YbD4YDL5UJmZqbWzSGZhKqzkmTLgbO0hnVWiIjigFz9t+IJtkTh2J2VSM+p+Hx1UAcs1iykOso5okJEREEYrJCmTCYz0rJGa90MIiLSMQYrREQkG0HwcbSUZMdghYiIZMH9vkgpDHeJiChm3O+LlMRghYiIYsL9vkhpDFaIiCgm3O+LlMZghYiIYsL9vkhpCZtgy4x1IiJ5cL8vUlpCBivMWCciko9/v69IU0Hc74tikXBDCcxYJyKSF/f7IqUl1CeHGetERMqwOytRUF47aEf1JFsOCsprOWpNMUmoaSApGessAU9EJA33+yKlJFSwwox1IiJlcb8vUkJCBSvMWCctcQUaEVF0EipYYcY6aYUr0IiIopdQt3XMWCctcAUaEVFsEq5XZsY6qYkr0IiIYpdQ00B+zFgntXAFGhFR7BIyWAGYsU7q4Ao0IqLYcSiBSEFcgUZEFDsGK0QK8q9Ai4Qr0IiIImOwQqQgrkAjIoodvyGJFMYVaEREsUnYBFsiNXEFGhFR9BisEKmEK9CIiKLD2zoiIiLSNQYrREREpGsMVoiIiEjXGKwQERGRrjFYISIiIl1jsEJERES6xmCFiIiIdI3BChEREekagxUiIiLSNQYrREREpGsMVoiIiEjXGKwQERGRrjFYISIiIl1jsEJERES6xmCFiIiIdI3BChEREekagxUiIiLSNQYrREREpGsMVoiIiEjXGKwQERGRrjFYISIiIl1jsEJERES6xmCFiIiIdI3BChEREelaktYNIBJDEHw442qCt7cDFmsWUh3lMJkYaxMRJQIGK6R7nvYGtB2sg7f3VOAxizUbuSNnwe6s1LBlRESkBt6akq552hvQ3LQmKFABAG/vKTQ3rYGnvUGjlhERkVoYrJBuCYIPbQfrIh7TfmgzBMGnToOIiEgTDFZIt87nqJyKeExfz0mccTWp1CIiItICgxXSLW9vh6zHERGRMTFYId2yWLNkPY6IiIyJwQrpVqqjHBZrdsRjkmw5SHWUq9QiIiLSAoMV0i2TyYzckbMiHuMsrWG9FSKiOMdvedI1u7MSBeW1g0ZYkmw5KCivZZ0VIqIEEFWwsn79epSUlCAlJQUTJkxAQ0PkWhdr167FqFGjkJqaiuLiYsyfPx9nz56NqsGUeOzOSpRUPoWiyxchf9Q9KLp8EUZctY6BChFRgpBcwfall15CbW0tNm7ciAkTJmDt2rWYNGkSDhw4gLy8vEHHv/jii3jwwQfx/PPP4+qrr8bHH3+MWbNmwWQyYc2aNbK8CIp/JpMZaVmjtW4GERFpQPLIypo1azBnzhzMnj0bl112GTZu3Ii0tDQ8//zzIY9/++23UVVVhWnTpqGkpATf/OY3cdtttw05GkNEREQESAxWent7sXfvXlRXV3/xC8xmVFdXY8+ePSHPufrqq7F3795AcHLo0CFs374dN9xwQwzNJiIyDp8goNHTjd0dnWj0dMMnCFo3ichQJE0Dtbe3w+v1Ij8/P+jx/Px87N+/P+Q506ZNQ3t7O6655hoIgoC+vj7cdddd+OlPfxr2eXp6etDT0xP4t9vtltJMIiLdaHB5UHeiDaf6vIHHspMsmFWYi0qHXcOWERmH4quBdu3ahRUrVuDpp5/Gu+++i1deeQXbtm3DsmXLwp6zcuVKOByOwE9xcbHSzSQikl2Dy4M1x5qDAhUAONXnxZpjzWhweTRqGZGxSApWnE4nLBYLWlpagh5vaWlBQUFByHMWLVqEGTNm4I477sDll1+Om266CStWrMDKlSvh84XegG7hwoVwuVyBn2PHjklpJhGR5nyCgLoTbRGP2dzczikhikgQfOjuaERn6250dzQm7MatkqaBrFYrxo8fj/r6ekyZMgUA4PP5UF9fj3nz5oU8p7u7G2ZzcExksVgAAEKYP1KbzQabzSalaUREutLUdWbQiMpAJ8/1oanrDEbb01RqFRmJp70BbQfrgjZ0tVizkTtyVsKVbpA8DVRbW4vnnnsOmzdvRlNTE+6++250dXVh9uzZAICZM2di4cKFgeMnT56MDRs2YMuWLTh8+DB27tyJRYsWYfLkyYGghYgo3nQMEahIPY4Si6e9Ac1NawbtPO/tPYXmpjXwtCfWilrJdVamTp2KtrY2LF68GM3NzRgzZgx27NgRSLo9evRo0EjKww8/DJPJhIcffhifffYZcnNzMXnyZCxfvly+V0FEpDNZSeJuxsQeR4lDEHxoO1gX8Zj2Q5uRnlORMNuNmIRwczE64na74XA44HK5kJmZqXVziIiG5BMEzDtwJOJUUE5yEtaVjYDZZFKxZaR33R2NOP5B+EUofkWXL9J9sUy5+u/ECMmIiFRmNpkwqzA34jE1BU4GKjSIt7dD1uPiAYMVIiKFVDrsqC0uQPaAqZ6c5CTUFhewzgqFZLFmyXpcPJCcs0JEROJVOuyoyExHU9cZdPR5kZVkQXl6KkdUKKxURzks1uxBybX9JdlykOooV7FV2uLIChGRwswmE0bb01CVlYHR9jQGKhSRyWRG7shZEY9xltYkTHItwGCFiCRggSoiddidlSgor4XFmh30eJItBwXltQlXZ4XTQEQkCgtUEanL7qxEek4Fzria4O3tgMWahVRHeUKNqPgxWCGiIfkLVA3kL1CViHd6RGowmcy6X56shsQLz4hIErEFqjglRERKYbBCRBGdH4IOvyoBAPp6TuKMq0mlFonnEwQ0erqxu6MTjZ5ubhpIZFCcBiKiiIxaoKrB5UHdibagCrLZSRbMKsxlfRMig+HIChFFZMQCVQ0uD9Ycax5U6v5UnxdrjjWjweXRqGXhcRSIKDyOrBBRREYrUOUTBNSdaIt4zObmdlRkpitW70QQfJJWcHAUiCgyBitEFJG/QFWo1UB+eipQ1dR1JuLmgQBw8lwfmrrOYLQ9Tfbnl7rE2z8KNJB/FKgWLMtPpI9vFyLSNSMVqOoYIlCRepwU/iXeA0eh/Eu8Pe0NQY+LHQXilBAlOo6sEJEoRilQlTVg08BYjxNL7BLv9JyKwHum9SgQkVEwWCEi0YxQoKo8PRXZSZaIQUBOchLK01NlfV4pS7z976GWo0BERqKvWyIiohiZTSbMKsyNeExNgVP25NpolnhrNQpEZDQMVogo7lQ67KgtLkD2gE4+JzkJtcXKJKxGs8TbPwoUiRKjQERGw2kgIopLlQ47KjLT0dR1Bh19XmQlWVCenqrYcuVolnj7R4FCrQbyU2IUiMhoOLJCRHHLbDJhtD0NVVkZGG1PU7TT9y/xjiTUEm85RoEEwYfujkZ0tu5Gd0cj92miuMORFSIimfiXeA+ss5Jky4GztCbsEu9YRoGk1nUhMiKTIOh/Ab/b7YbD4YDL5UJmZqbWzSEiikhqBdto+eu6hKO3GjiUeOTqvzmyQkQkMzWWeEdT14XIqPgJJiIyICl1XYiMjsEKEZEBRVPXhcioGKwQERlQNHVdiIyKwQoRkQH567pEMrCuC5FRMVghogCfIKDR043dHZ1o9HRzt18di7auC5ERcTUQEQEAGlwe1J1oC9oAMDvJglmFuYqUp6fYRVvXhchoGKwQERpcnpAl30/1ebHmWDNqocx+OhQ7u7MS6TkVqtR1IdIKgxWiBOcTBNSdaIt4zObmdlRkpnOPGp1So64LkZYYehMluKauM0FTP6GcPNeHpq4zKrWIiCgYgxWiBNcxRKAi9TgiIrkxWCFKcFkDdvuN9TgiIrkxWCFKcOXpqcgeIhDJSU5CeXqqSi0iIgrGYIUowZlNJswqzI14TE2Bk8m1RKQZBitEOqdGobZKhx21xQWDRlhykpNQW8xly0SkLS5dJtIxNQu1VTrsqMhMR1PXGXT0eZGVZEF5eipHVIhIcwxWiHRKi0JtZpMJo+1psv5OIqJYcRqISIfEFmrj3j1ElAgYrBDpEAu1ERF9gcEKkQ6xUBsR0RcYrBDpEAu1ERF9gcEKkQ6xUBsR0RcYrBDpEAu1EZGcBMGH7o5GdLbuRndHIwTBp3WTJOHSZSKdqnTYUYuCQXVWcpKTUFPgZKE2IhLF096AtoN18PaeCjxmsWYjd+Qs2J2VGrZMPJMg6H/to9vthsPhgMvlQmZmptbNIVKVTxBYqI2IouJpb0Bz05qw/19QXqtowCJX/82RFSKNDRWMJEKhNgZk+sVrY1yC4EPbwbqIx7Qf2oz0nAqYTPrOCmGwQqQhNcvp65We34NE76j1fG1oaGdcTUFTP6H09ZzEGVcT0rJGq9Sq6DBYIdKIFuX09UbP70Gid9R6vjYkjre3Q9bjtKTvcR+iOMVy+sq+B7HuVO3vqAdWEfZ31A0uj+Q2GQk/n/HBYs2S9TgtcWSFSANSyunHa76KUu9BrCMiYjvqcRlpONB9Ni6niPj5jA+pjnJYrNkRp4KSbDlIdZSr2KroMFgh0gDL6SvzHsgxdSG2o777wBF0er+oVRFPU0T8fMYHk8mM3JGzIq4GcpbW6D65FuA0EJEmWE5f/vdArqkLsR1w/0AFiK8pIn4+44fdWYmC8lpYrNlBjyfZchRftiwnjqwQacBfTj/SHbyRy+mLWUUj93sg19RFrB3w5uZ2VGSmG3pKKN4/n4nG7qxEek7F56uDOmCxZiHVUW6IERU/BitEGvCX0w81ZeFn1HL6YnNG5H4P5Jq6ENNRRxIPuRzx/PlMVCaTWffLkyMxTlhFhhPriox4V+mwo7a4YNCGhTnJSagtNuayUKmraOR8D2KZuuj/WW3qOoOZhU7RzxtKPORyxOPnk4yLIyukiESvUSFWpcOOisz0uCg8JjZnZOAUiVzvQbRTF+E+q5NzsrDb1Rn0eKbFDLd36A3g5MrlEASfpkP38fT5JGNjsEKyYzEpaeKlnH4sOSNyvAfRTF1E+qz+8WQH7rsgHxlJlkBHPSotBf/x8Seq5HLoZfO5ePl8krFxGohkxWJSiUvs1Mfpvj7FpgelTF2I+az+puUkytNTUZWVgdH2NCSZzZhVmBvxHDlyOfybzw2sj+HtPYXmpjXwtDfE9PuJjIYjKyQrFpNKXGKnPjYfb0enT7n6JGKnLqL9rFY67KhFwaCpo5zkJNQUOGN+HfG0+RyRXKL6pK9fvx4lJSVISUnBhAkT0NAQOcrv6OjA3LlzUVhYCJvNhrKyMmzfvj2qBpO+sZiUcqJJWFYzydmfMzKU/oEKoEx9Ev/UhX9EJNRIRyyf1UqHHU+NKsGikiLcc0E+FpUUYV3ZCFkCLimbzxElCskjKy+99BJqa2uxceNGTJgwAWvXrsWkSZNw4MAB5OXlDTq+t7cX3/jGN5CXl4eXX34Zw4cPxyeffIKsrCw52k86w2JSyogmYVntJGcxOSORqF2fJNbPqlK5HPG0+Vx/WicLk7FJDlbWrFmDOXPmYPbs2QCAjRs3Ytu2bXj++efx4IMPDjr++eefx6lTp/D2228jOTkZAFBSUhJbq0m3WExKftEkLGuV5BxuikTMKhq1pwf1+lmNp83n/PSSLEzGJSms7e3txd69e1FdXf3FLzCbUV1djT179oQ85w9/+AMmTpyIuXPnIj8/H1/60pewYsUKeL3hvyB6enrgdruDfsgY/HfXkbCYlHhikkCfPd4aNL2jdZJzqCmSGQXi6paoOT2o18+qf/O5SIyy+RzAZGGSh6Rgpb29HV6vF/n5+UGP5+fno7k59NDvoUOH8PLLL8Pr9WL79u1YtGgRHn/8cTz66KNhn2flypVwOByBn+LiYinNJI2xmJR8xCSBerw+vNL6RUcgJXFUKQNzRrKTxQ3iKj09ODCHpyIzXXefVf/mc5EYZfM5scnCgjB07RpKbIqvBvL5fMjLy8Ozzz4Li8WC8ePH47PPPsPPf/5zLFmyJOQ5CxcuRG1tbeDfbrebAYvBsJiUPMSONOw45cLNedkwm0y6THLWw5RLpByep0aVBH1WR6Wl4ED3Wezu6NTks+vffG7g1EmSLQfO0hrDTJ1ISRY2cil4Up6kYMXpdMJisaClpSXo8ZaWFhQUFIQ8p7CwEMnJybBYvrhzKS8vR3NzM3p7e2G1WgedY7PZYLPZpDSNdIjFpGIndqTB4/UF8j2UTHIWs0FhKFrvNTNkDk+/UZQGl2dQ4Tctqi/Hw+Zz8ZosTOqTFKxYrVaMHz8e9fX1mDJlCoDzIyf19fWYN29eyHOqqqrw4osvwufzwWw+/0f28ccfo7CwMGSgQkRfKE9PRbrZhC7f0Pkl/pESpUYxYl1dpHR9knCkbAPwjrtLV9WXjbr5nNfrxblz59CHTHhNkfNvAKAPmTh79qwKLSO5DRyMUIrkaaDa2lrU1NSgoqIClZWVWLt2Lbq6ugKrg2bOnInhw4dj5cqVAIC7774bTz31FO69917cc889+Oc//4kVK1bgP/7jP+R9JRTXor2jNzqzyYQbcrLwu7bTQx7rHylRYhRDzOoiMdN+WkwPis3h+ajrTFR7G9EXBEFAc3MzOjo6Pn/Egj77tIg5KSaTBc0nLcDJw6q0keSXlZWFgoICmBT8u5AcrEydOhVtbW1YvHgxmpubMWbMGOzYsSOQdHv06NHACAoAFBcX44033sD8+fNxxRVXYPjw4bj33nvxwAMPyPcqKK4l+qaIN+Vl4/VTLngiLP0dOFIi5yiGmJGJ5463YtNx4LR36Mq0ak8Pis3NafR0K1Z9OVGCbX+gkpeXh7S0NJhMJnjPFaCvtz3sOUlWJyzJnC42IkEQ0N3djdbWVgDn0z6UYhIE/W/S4na74XA44HK5kJmZqXVzSEXh7uj9EmV1UbTvgxydZKOnG8uOHJfc5qHaphax7b/JOQxb24cewbrngnxUZWWIfv5ECba9Xi8+/vhj5OXlIScnJ/j/znWhr6cdgtAXeMxkTvo8UElXu6kks5MnT6K1tRVlZWWDpoTk6r+Nk6lFCUfreiF6Eu1ycDFl54cS66ohra+RmG0AcpKTcFl6iqjfJyUx2R9kDhyxEbvFgJrbJcTq3LlzAIC0tMGjJJbkdFjTL0RyahGSU/KRnFoEa9qFDFTihP+a+z8DSuBGhqRbRt0UUakhf62Wg8da+0SOaxTLeyo2h2e0PU3WxGQpib2hXotRR2TC5S2YTCZYkli5Oh4pmavix2CFdEuP9UKGonQHo8VycDGri4YSyzWS4z0Vm8MjZ2JyLMG2VtslEOkVgxXSLaNtijhUB3PL2WGBwm1KUWJUJ9YNCoHor5GcnbaYkSk5E5OjDbZjHZFRSqIkCZM+MVgh3dJD1VOxxHQwL7edRv0pF2YX5SlyV6zkqE64TlyMDIs5qmukRKcdbmRqYEf8i7IRONB9NqaOOdpgW4/Tn0adklKLyWTC1q1bA/XHSH4MVki3tK56KoWYDgY4v7RX7mF8nyDgldZTeDlELRY5pw36j0w0uD1445S4DUY7vT5sbT2FAptVUsevVqcdqSOWsupnoGiDbb1Nf2oxJZWoozjnzp1DcnKy1s3QJa4GIl0zyqaIUjsOuVbINLg8mLv/cMhARYnn849MVGZKe99/13Ya6z5twbIjxzHvwJEhV8EA6nTasa7WiUTMrs4zCnIGdcJ6mv7UYkVeg8uDeQeOYNmR45I/M9F49tlnUVRUBJ8vuI7Rd77zHfzgBz8AAGzYsAEjR46E1WrFqFGj8Jvf/CZwXElJCQDgpptugslkCvwbAH7/+99j3LhxSElJQWlpKZYuXYq+vn7Lt00mbNiwAd/+9reRnp6O5cuX4/Tp05g+fTpyc3ORmpqKSy65BJs2bVLktRsJgxXSvUqHHU+NKsGikiLcc0E+FpUUYV3ZCN0EKoD0jkOOXY/9He3pCMXi+j/f6+0dsnUqYpYDhyM2EFC601ajIw4XbPv9+kT7oPdB7FJrNaY/1d7BW8ngMZzvfe97OHnyJP785z9/8XynTmHHjh2YPn06tm7dinvvvRc//vGP8eGHH+KHP/whZs+eHTj+H//4BwBg06ZNOHHiRODff/3rXzFz5kzce++9+Oijj/DMM8+grq4Oy5cvD3r+Rx55BDfddBM++OAD/OAHP8CiRYvw0Ucf4fXXX0dTUxM2bNgAp9Mp++s2GgYrZAhy1AtRUjSddywjAmI62oF+03JStjtUMaMGQxkqEFC601arI6502DGzIHRnE6oTFvPeqjX9qeaUlFZ1lYYNG4brr78eL774YuCxl19+GU6nE9dddx1Wr16NWbNm4Uc/+hHKyspQW1uLm2++GatXrwYA5Oaev1b+kvP+fy9duhQPPvggampqUFpaim984xtYtmwZnnnmmaDnnzZtGmbPno3S0lJceOGFOHr0KMaOHYuKigqUlJSguroakydPlvU1GxGDFSIZRNN5xzKMLzZHZiA571ArHXbcd0E+ou0yhwoElO601eqIfYKAXzeHLzcPDO6E9TL9qeaUlNqjOP1Nnz4d//M//4Oenh4AwAsvvIDvf//7MJvNaGpqQlVVVdDxVVVVaGpqivg733//ffzsZz+D3W4P/MyZMwcnTpxAd3d34LiKioqg8+6++25s2bIFY8aMwf3334+3335bpldpbEywJZKJlBUzsQ7jy1FVVo6lrxlJFsRynzvU61Byp2a1OuJoE4W1KgLYn5Qk4d7PO/poaZlYPHnyZAiCgG3btuGqq67CX//6VzzxxBMx/U6Px4OlS5fi5ptvHvR/KSlfVEtOTw+u4nv99dfjk08+wfbt27Fz5058/etfx9y5cwMjOYmKwQqRjPwdzNbWUxF3So51GF8PVWWB2DsOMa9DqU5braXxsXTCWhQBHPj8aq3I0zKxOCUlBTfffDNeeOEF/Otf/8KoUaMwbtw4AEB5eTl2796NmpqawPG7d+/GZZddFvh3cnIyvN7g6zdu3DgcOHAAF198seT25ObmoqamBjU1Nbj22muxYMECBitaN4Ao3phNJnw3PwdnfQJeO9kRNPJgBnBjTlbMw/haV5X1i6XjkBIIKNFpq9UR62l1TzSUHN3qT+u6StOnT8e3vvUtNDY24t///d8Djy9YsAC33norxo4di+rqavzxj3/EK6+8gjfffDNwTElJCerr61FVVQWbzYZhw4Zh8eLF+Na3voULL7wQt9xyC8xmM95//318+OGHePTRR8O2Y/HixRg/fjxGjx6Nnp4evPbaaygvL1fkNRsJc1aIFNDg8uCPAwIVAPAB+OPJjphzRuRIcJWjcyxPT4XdEt3XyIz8wct21aZGboieVvdES40VeVonFn/ta19DdnY2Dhw4gGnTpgUenzJlCp588kmsXr0ao0ePxjPPPINNmzbhq1/9auCYxx9/HDt37kRxcTHGjh0LAJg0aRJee+01/OlPf8JVV12F//f//h+eeOIJjBgxImI7rFYrFi5ciCuuuAJf/vKXYbFYsGXLFkVes5GYBEHH23h+Tq4tponU4BMEzDtwZMg7xHVlI2L+4g1X0KxXEOCJsKQ5mucPV6jr5ZaTQ9Z5CUVPFVCVLkIWrrCan55qBkXr7NmzOHz4MC666KKgnAypQn2m5R7FIXlFuvZy9d+cBiKSmZrl0sPlc7zj7pJ1eiNSldeb87Kx46QLHt/Q9V7609OmfP2nmZQIXPxTKc9+1jrofYp2ZCpe6SGxmPSHwQqRzNRe1RAqn0POPIMhy60XF+DO4XlRb3T4y+OtGJeRhiSz9p220nvghAroPApswWB0WicWk/4wWCGSmV4SKuW4QxVbqGtd2QjUFke30aHb68Pd+49gznBlNngUS8k9cPS6kzKRUTBYIZLZUKsaTIIPV+AYirub0d03DKmOcphMyowqDLxD9QkCGj3dooMXKVNa/YOjDz3d2NreIbqdnT5tRxeUDib0uJMykZEwWCGSWaQlsZf1NuLG7m1wCG60dpx/zGLNRu7IWbA7KxVtVzRTHFKntPzBUbRTXFqNLigdTOhtJ2Uio9F+kpgoDoVaEntZbyNu6/pvZAruoGO9vafQ3LQGnvYGxdoT7QZx0U5pRTvFpVQ59aEoHUzoZWqQyKg4skKkkKCckXPnkHdgR8R9dNoPbUZ6ToXsU0KxTHFEW6grlqJ1WowuKB1MaFnwTOll2URq4MgKkYL80yJjTZ/CdC5yLZK+npM444q8OVo0xE5xvN7eMWhH22gLdcVStE6L0QWlC7dpVfCsweXBvANHsOzIcaz7tAXLjhyXbedtIjUxWCFSgbe3Q9bjpNjr7hJ13G9aTobsyMRUefUn7u7u6ESjpxs+QQh7XiRaVXJVI5hQeyflaKf+iPSI00BEKrBYs2Q9TqwGlwfbT7lEHx9umW6kZdBDJe72P6+5p1fRDR5jocYeOGoVPONSaWP46le/ijFjxmDt2rUAzu8xdN999+G+++4Le47JZMLWrVsxZcoUVdqoFwxWiFSQ6iiHxZoNb++psMck2XKQ6pBvwzIxHVY4oTqyUIW6xNYm6X9ecYpNt+XU1Qgm1Ch4xqXSxvSPf/wD6enpsv7ORx55BK+++ir27dsn6+9VG4MVIhWYTGbkjpyF5qY1YY9xltbImlwrpsMKR0xHFu3du97LqcdD9VSjL5UWBB/OuJrg7e2AxZqlaC0iPcnNjW1z0ngW/1efSCfszkoUlNfCYs0OejzJloOC8lrZ66zE2hENdb6Uu/eB/AFBVVYGRtvTdBOoxAsjL5X2tDfgSMM8HP9gGVoOrMPxD5bhSMM8RZf2A4DP58Njjz2Giy++GDabDRdeeCGWL18OAHjggQdQVlaGtLQ0lJaWYtGiRTh37lzg3EceeQRjxozBb37zG5SUlMDhcOD73/8+Ojs7A8d0dXVh5syZsNvtKCwsxOOPPz6oDSUlJYEpIQD45z//iS9/+ctISUnBZZddhp07dw46J1Lb6urqsHTpUrz//vswmUwwmUyoq6sDAHR0dOCOO+5Abm4uMjMz8bWvfQ3vv/9+4Pe+//77uO6665CRkYHMzEyMHz8e77zzTkzvcSw4skKkIruzEuk5FarcNcbaEQ11fix371xOqywtl0rHwtPeEHL00V+LSImg3m/hwoV47rnn8MQTT+Caa67BiRMnsH//fgBARkYG6urqUFRUhA8++ABz5sxBRkYG7r///sD5Bw8exKuvvorXXnsNp0+fxq233opVq1YFAp4FCxbg//7v//D73/8eeXl5+OlPf4p3330XY8aMCdken8+Hm2++Gfn5+fj73/8Ol8sVMpclUtumTp2KDz/8EDt27MCbb74JAHA4HACA733ve0hNTcXrr78Oh8OBZ555Bl//+tfx8ccfIzs7G9OnT8fYsWOxYcMGWCwW7Nu3D8nJyTK+49IwWCFSmclkRlrWaMWfJ5ZaJ2I6smjv3pXeLJAiV1H20zKZORRB8KHtYF3EY5SqRdTZ2Yknn3wSTz31FGpqagAAI0eOxDXXXAMAePjhhwPHlpSU4Cc/+Qm2bNkSFKz4fD7U1dUhIyMDADBjxgzU19dj+fLl8Hg8+NWvfoX/+q//wte//nUAwObNm3HBBReEbdObb76J/fv344033kBRUREAYMWKFbj++uuDjovUttTUVNjtdiQlJaGgoCBw3FtvvYWGhga0trbCZrMBAFavXo1XX30VL7/8Mu68804cPXoUCxYswKWXXgoAuOSSSyS+q/LiNBBRnIql1omYjiya2iRcTqsetZdKx+r8aGP4BHRAwVpETU3o6ekJBBIDvfTSS6iqqkJBQQHsdjsefvhhHD16NOiYkpKSQKACAIWFhWhtbQVwftSlt7cXEyZMCPx/dnY2Ro0aFbFNxcXFgUAFACZOnBhV2wZ6//334fF4kJOTA7vdHvg5fPgwDh48CACora3FHXfcgerqaqxatSrwuFY4skKkoHDTHWpNg0Rajnt1ph27XZ1hV+UM1Uapd+9iEnKfPd6KNIsZl3FaSBZ6T2buT8taRKmp4UcR9+zZg+nTp2Pp0qWYNGkSHA4HtmzZMijnZOAUiclkgs/nk72t0bRtII/Hg8LCQuzatWvQ/2VlZQE4n4czbdo0bNu2Da+//jqWLFmCLVu24KabblLglQyNwQqRQsJNd1Q5MgYFCUpOg0TqsG4ryImqdkr/3y22NomYhFyP14dHjxyPq2khrfNzjLK6SataRMD5KY7U1FTU19fjjjvuCPq/t99+GyNGjMBDDz0UeOyTTz6R9PtHjhyJ5ORk/P3vf8eFF14IADh9+jQ+/vhjfOUrXwl5Tnl5OY4dO4YTJ06gsLAQAPC3v/1NctusViu83uC/u3HjxqG5uRlJSUkoKSkJ2+6ysjKUlZVh/vz5uO2227Bp0yYGK0RK0KqjiFR/5I8nO0I+HqoYm1zCdVix1E7xE3v3LmV1kpzvh5bBgp7yc7QOmoaiRS0iv5SUFDzwwAO4//77YbVaUVVVhba2NjQ2NuKSSy7B0aNHsWXLFlx11VXYtm0btm7dKun32+123H777ViwYAFycnKQl5eHhx56CGZz+EyM6upqlJWVoaamBj//+c/hdruDghIAotpWUlKCw4cPY9++fbjggguQkZGB6upqTJw4EVOmTMFjjz2GsrIyHD9+HNu2bcNNN92E0aNHY8GCBbjllltw0UUX4dNPP8U//vEPfPe735X0uuXEYIXillYdhdzF2NQUbe0UMXfv0axO2nyiLab3Q8tgQWrQp3Rb9BI0haNFLaL+Fi1ahKSkJCxevBjHjx9HYWEh7rrrLtx+++2YP38+5s2bh56eHtx4441YtGgRHnnkEUm//+c//zk8Hg8mT56MjIwM/PjHP4bLFb66tNlsxtatW3H77bejsrISJSUl+MUvfoF/+7d/Cxzz7W9/e8i2ffe738Urr7yC6667Dh0dHdi0aRNmzZqF7du346GHHsLs2bPR1taGgoICfPnLX0Z+fj4sFgtOnjyJmTNnoqWlBU6nEzfffDOWLl0q9W2VjUkQBuxcpkNutxsOhwMulwuZmZlaN4cMIFxH4adkgmGjpxvLjhyP+vxFJUUhO3417ozFtj1cGyPxCQLmHTgieXXS93KH4bv5OZLOAbT9DPgEAXfuPwyPN3zOQk5yEtaVjVA8MFXrfTh79iwOHz6Miy66CCkpKVH/Hk97A9oO1gWNsCTZcuAsrVFs2TLFJtK1l6v/5sgKxR2t90VRohibWnfGSlY+NZtMmFngxNpPWySd97u20yhOsUl6nVp/Bra2nooYqADqlLvX+n2Ihpq1iMg4ePUp7sRSWVUOchdjU3O5r5KVTxtcHvy6uV3yecD5DtUnYRBYy8+ATxCwPUReUihKl7vX+m8hWv5aRBl5VUjLGs1AhRisUPzRel8UMfVHwhlYl0TsnXH/jtwnCGj0dGN3RycaPd2SOvloaqeIES7gEktqh6rVZ8AnCHi9vQNdPnHvudLl7rX+WyCSC6eBKO5ovS+KmPoj4QwsxiZ199xYp4uUqHwaS8Jxf1I6VC0+A6He+0jsFrPi5e61/lsgkgtHVijuKDU6IEWk6qGTc7JEVxWVcmcs13SR3JVPY9n9uT8pHaran4FoRo7+LduheJ6IHv4WiOTAkRWKO3rZFyWaYmwDie2gHUkWPD1E4qqUREo5K5/KMcUgtUON9jMQzYqraEaO7BYzbs7LHvrAGGnxt2CABaYkMzWuOYMViktSKqsqSUoxtlDE7p4rCIKk6SIx5Kh86hMEdJzri+l3ANF1qFI/A5Gm0CIFbtGMHN1ZlKfa6hu1/hb85ea7u7sjlq+n+NPd3Q1g8JYDcmKwQnHLSPuihCP2ztg9xDJZPzUTKaXmcADn56X7v5JYO1Sxn4GhCrjZLeagpcj984CkvKdaFWJT42/BYrEgKysrsHlfWloaTAb6WyPpBEFAd3c3WltbkZWVBYtFudwnBitxTO/ltdVglH1RIhFzZ9zo6Rb1u9RKpByqEFk4/3FBPjKSLLJ+Zof6DIiZxhlYM6V/FVqjJKeq8bdQUFAAAIGAhRJDVlZW4NorhcFKnDJCeW0Sb6g7Y7HTRWokUkaTw6H29Fx/sSQAb25ux5OXXDjke++nRal9NZlMJhQWFiIvLw/nzp3TujmkguTkZEVHVPwYrMQhPe1JQvKJdGesl6RiQHzn/41hmShLS0H250GUVqN+sUyNnTzXhwPdZyUvVR+Y7Bxvo6AWi0WVDowSB4OVOGPE8toULNqOSy9JxWI7/7K0FFw7TPu9vmKdxuno86IqKyPkex+OnLVxiBIBg5U4I7WIGOlLrB2XHpKKxXb+v25uh81sDrwurUYXxEyhReJ/vZUOO8ZlpOGO/YdxVkQF2/61cQbiKChRMAYrcYbltY1Lro5L66TiTpGfrU6vL/C6AGg2uhBLxeGBeUAHus+KClQAINNixobPIieichSU6DxWsI0zLK9tTNHsAaRHPkGQvFnhs8dbVduoMZxwVXvtlshfkQPzgMTeBNgtZphMJkNuMkikBY6sxBk9rQoh8eJl+i6alTUDlwUPpNboQrgptHfcXaLzgMTeBFyf7YCLo6BEojFYiTN6WhVC4sUyfaenlSRKdKxqBmmhptCk5AGJuVnIsJhxU1626BETjoISMViJS3pZFULiRTt9p7eVJEp1rP4gSKvATGwekJibhTmfl9rnKCiReAxW4pQeVoWQeNF0XNEm5CrZ4ce6siacrCSL7gKzcMTeLHAUlEg8k2CALTLdbjccDgdcLhcyM7Wvy0D6pacpEamGKlFfW1wQtMx33oEjQwY368pGBL1+NTp8qaX2B+67M1BOchJm5OdgbYRdpfu/N3oh9rMY6ppwFJTihVz9N4MVihtGufOORGzH1ejpxrIjx4f8fYtKigLTF1KCoViFeh0DNynMtJjxg6JcmGGK2K77ivPx6xPtkgMzPRkqcDFykE0UiVz9N6eBKC7ES3EtsdN3UhNy1a5sHOp1uPr6sOl4Ozp950MWt9eHX59ox6zCXNQWh582SbeYFV8ppWSwICaI1ro2DpHeMVghw4u3LQbEdFxSE3K1WBrd/3U0uDz4xaeDC6AFgsniAjw1qiRkwLC7o1PU80W7EknJEbl4CaKJtMaicGR4UjrieOFPZI2kf0KulpWNxQaTADDanoaqrAyMtqcFAkslCx36gwklCtLFS6E/Ij2IKlhZv349SkpKkJKSggkTJqChoUHUeVu2bIHJZMKUKVOieVqikBJxiwH/SpJI+q8k0bKycazBpKjALMkCnyBgd0cnGj3dogIApYOJRAyiiZQiOVh56aWXUFtbiyVLluDdd9/FlVdeiUmTJqG1NfIeF0eOHMFPfvITXHvttVE3liiURN1iIFyJ+JzkpEHJslJHYuQUazApJjDr8QlY/skJrPu0BcuOHMe8A0eGHBVROphIxCCaSCmSg5U1a9Zgzpw5mD17Ni677DJs3LgRaWlpeP7558Oe4/V6MX36dCxduhSlpaUxNZhoIC07Yq1VOux4alQJFpUU4Z4L8rGopAjrykYMyoOQOhIzkE8Q0OjpljRy4SdHMBkuMMv4fO8ejy946bOYaRylg4lEDaKJlCApwba3txd79+7FwoULA4+ZzWZUV1djz549Yc/72c9+hry8PNx+++3461//OuTz9PT0oKenJ/Bvt9stpZmUYBK9uJbYlSTRVjaONQFVrkqtA1cYOZIsWD9EPZdIidVKBxOsUEskH0nBSnt7O7xeL/Lz84Mez8/Px/79+0Oe89Zbb+FXv/oV9u3bJ/p5Vq5ciaVLl0ppGiU4bjEgjtTKxnKsZpEzmOwfmDV6unF6iE0QI61wUjqYkDuIZi0WSmSKLl3u7OzEjBkz8Nxzz8HpdIo+b+HChaitrQ382+12o7i4WIkmUhzxd8QfdZ1Bo6cbgAmXpackVP0KMR2a2JEYOZeEKxFMypULo+SInFyvOx4KHhLFQlKw4nQ6YbFY0NISXPa6paUFBQUFg44/ePAgjhw5gsmTJwce830+t5yUlIQDBw5g5MiRg86z2Wyw2WxSmkYEAHjH3RX0pb61PXG+1OXu0OSuzSL3flWy5cIoPCIX6+tmrRYiicGK1WrF+PHjUV9fH1h+7PP5UF9fj3nz5g06/tJLL8UHH3wQ9NjDDz+Mzs5OPPnkkxwtIVkl8pe6Eq9diQRUOSu1KpULo8QUS7SvO94KHhJFS/I0UG1tLWpqalBRUYHKykqsXbsWXV1dmD17NgBg5syZGD58OFauXImUlBR86UtfCjo/KysLAAY9ThSLRP5Sl+O1h5o+0vtqFqVyYfREi8rDRHokOViZOnUq2trasHjxYjQ3N2PMmDHYsWNHIOn26NGjMJtZGJfUlchf6rG+9nDTRzMLnbpfzRLvidWs1UJ0XlQJtvPmzQs57QMAu3btinhuXV1dNE9JFFEif6nH8tojTR+tPdaCyTlZ+OPJjrC/Uw9LwtWYxtGK3ke3iNTCjQwpLiTyl3q0r13M9NHbbg/uuyAfv25u1/XIhV6ncWLFWi1E5zFYobiQyF/q0b52sdNHGUmWsDsik7ISveAhkR+TSyguxFpO3siife1Spo/8IxcDd0Qm5UnZA4ooXnFkheJGvCdbRhLNa0/kqTOjiee8HCIxGKxQXEnkL3Wprz2Rp86MKF7zcojEYLBCcSeRv9SlvHbmQxCRUTBnhSiBMR+CiIyAIytECS6Rp86IyBgYrBBRQk+dEZH+MVghItJQqH2ZOKpFFIzBChGRRsLtyzSrMJf5QkT9MMGWiIL4BAGNnm7s7uhEo6cbPkHQuklxyb8v08Cl46f6vFhzrBkNLo9GLSPSH46sEFEA7/TVIWZfps3N7ajITOeUEBE4skJEn+OdvnrE7svU1HVGpRYR6RuDFSISfafPKSF5SNmXiYgYrBAReKevNu7LRCQNc1aI4kQsS2B5p68u7stEJA2DFaI4EGtiLO/01cV9mb4gCD6ccTXB29sBizULqY5ymEwc9KdgDFaIDM6fGDuQPzG2FkPv8cM7ffVVOuyoRcGgIDMnOQk1Bc6oVl8ZrcCcp70BbQfr4O09FXjMYs1G7shZsDsrNWwZ6Q2DFSIDk2sJLO/0tSHnvkxGW3buaW9Ac9OaQY97e0+huWkNCsprGbBQAMfaiAxMzsRY7sAcTK3ieP59maqyMjDanhZ1oGKkZeeC4EPbwbqIx7Qf2gxB8KnTINI9jqwQGZjcibHcgfk8I41SGLHA3PkclVMRj+nrOYkzriakZY1WqVWkZxxZITIwJRJj5bjTNzKjjVIYcdm5t7dD1uMo/jFYITIwf2JsJEyMFc+IxfGMuOzcYs2S9TiKfwxWiAzMnxgbCRNjxTPiKIURl52nOsphsWZHPCbJloNUR7lKLSK9Y7BCZHBMjJWPEUcpjDi6ZjKZkTtyVsRjnKU1rLdCAUywJYoDTIyVhxFHKYy67NzurERBee2gOitJthw4S2u4bJmCMFghihP+xFiKnlGL4ylRYE4Ndmcl0nMqWMGWhsRghYjoc0qMUqhVVdaoo2smk5nLk2lIDFaIKCpGK+0ulpyjFGrXa+HoGsUrBitEJJmRiqZFoyIzHWkWMxo93QBMuCw9RXLNGTn2bCKi8xisEBmEXkYy4r0TDhWI/V+HtEDMiFVlifSMwQqRAehlJCPeO2G5AjEp9Vo4bUM0NKZcE+mcnsq/G7FomlhyVq81Yr0WIj1jsEKkY3or/x7PnbCcgZgR67UQ6RmDFSId09tIRjx3wnIGYkasKkukZwxWiHRMbyMZ8dwJyxmIcc8mInkxWCHSMb2NZMRzJyx3IMY9m4jkw9VARDqmx/LvRi3tPhQlqtcataoskd4wWCHSMb1uUhevnbASgRiryhLFziQIKi0jiIHb7YbD4YDL5UJmZqbWzSFSXag6K0YfydAzvRTgIzI6ufpvjqwQGUC8jmToFUdDiPSFwQqRQbADJaJExdVAREREpGsMVoiIiEjXGKwQERGRrjFYISIiIl1jsEJERES6xmCFiIiIdI3BChEREeka66zIRBB8OONqgre3AxZrFlId5TCZGAsSERHFisGKDDztDWg7WAdv76nAYxZrNnJHzoLdWalhy4iIiIyPt/4x8rQ3oLlpTVCgAgDe3lNobloDT3uDRi0jIiKKDwxWYiAIPrQdrIt4TPuhzRAEnzoNIiIiikMMVmJwPkflVMRj+npO4oyrSaUWERERxR8GKzHw9nbIehwRERENxmAlBhZrlqzHERER0WBcDRSDVEc5LNbsiFNBSbYcpDrKVWwVDcRl5URExsZgJQYmkxm5I2ehuWlN2GOcpTXsGDXEZeVERMbHXjRGdmclCsprYbFmBz2eZMtBQXktO0QNcVk5EVF8iCpYWb9+PUpKSpCSkoIJEyagoSH8l/5zzz2Ha6+9FsOGDcOwYcNQXV0d8XgjsjsrUVL5FIouX4T8Ufeg6PJFGHHVOgYqGuKyciKi+CE5WHnppZdQW1uLJUuW4N1338WVV16JSZMmobW1NeTxu3btwm233YY///nP2LNnD4qLi/HNb34Tn332WcyN1xOTyYy0rNHIyKtCWtZoTv1ojMvKiYjih0kQBEHKCRMmTMBVV12Fp556CgDg8/lQXFyMe+65Bw8++OCQ53u9XgwbNgxPPfUUZs6cKeo53W43HA4HXC4XMjMzpTSXElRn6260HFg35HH5o+5BRl6VCi0iIko8cvXfkm7/e3t7sXfvXlRXV3/xC8xmVFdXY8+ePaJ+R3d3N86dO4fs7Oywx/T09MDtdgf9EEnBZeVERPFDUrDS3t4Or9eL/Pz8oMfz8/PR3Nws6nc88MADKCoqCgp4Blq5ciUcDkfgp7i4WEoziQLLyiPhsnIiImNQNbFi1apV2LJlC7Zu3YqUlJSwxy1cuBAulyvwc+zYMRVbSfHAv6w8Eq2XlQuCD90djehs3Y3ujkZdJvsaoY1EFP8k1VlxOp2wWCxoaWkJerylpQUFBQURz129ejVWrVqFN998E1dccUXEY202G2w2m5SmEQ3iX1Y+sM5Kki0HztIaTVdrGaH+ixHaSESJQVKwYrVaMX78eNTX12PKlCkAzifY1tfXY968eWHPe+yxx7B8+XK88cYbqKioiKnBRFLYnZVIz6nQVQVbf/2Xgfz1X/RQn8cIbSSixCG5gm1tbS1qampQUVGByspKrF27Fl1dXZg9ezYAYObMmRg+fDhWrlwJAPjP//xPLF68GC+++CJKSkoCuS12ux12u13Gl0IUmn9ZuR6Irf+SnlOhWUBlhDYSUWKRHKxMnToVbW1tWLx4MZqbmzFmzBjs2LEjkHR79OhRmM1ffIFt2LABvb29uOWWW4J+z5IlS/DII4/E1noig5FS/0WrAMsIbSSixBLV3kDz5s0LO+2za9euoH8fOXIkmqcgikve3g5Zj1OCEdpIRImFY7hEKjJC/RcjtJGIEguDFSIVGaH+ixHaSESJhcEKkYqMUP/FCG0kosTCbxsilfnrvwwcvUiy5ehmSbAR2khEiSOqBFsiio0e678MZIQ2ElFiYLBCpBE91X8JxwhtJKL4x1skIiIi0jWOrBARERmMIPgSaoqWwQrREBLtS4GI9C0RNxllsEIUQSJ+KRCRfiXqJqO8PSQKw/+lMHCfHP+Xgqe9QaOWEVEiErvJqCD41GmQihishCAIPnR3NKKzdTe6Oxrj8sJTZIn8pUBE+iRlk9F4w2mgATjsTwB3HtYa84SIBkvkTUYZrPSTqHOBNFgifylojTcMRKEl8iajvFX5HIf9qb9E/lLQEvOEiMJL5E1GGax8LpHnAmmwRP5S0ApvGIgiS+RNRuPvFUWJw/7UXyJ/KWiFNwxEQ0vUTUaZs/I5DvvTQP4vhYH5E0m2HDhLa+L2S0ErvGEgEicRNxllsPI5/7B/pDs7DvsnnkT8UtAKbxiIxEu0TUb5jfs5DvtTOP4vhYy8KqRljeZnQCHMEyKicPit20+izgUS6QFvGIgoHE4DDcBhfyLtME+IiEJhsBJCos0FEumJ2BsGVrklShwMVohId4a6YWCVW6LEwtsQIjIUVrklSjwMVojIMFjlligxMVghIsNglVuixMRghYgMg1VuiRITgxUiMgxWuSVKTAxWiMgwWOWWKDExWCEiw2CVW6LExL9oIjIUbotBlHhYFI6IDIfbYhAlFgYrRGRI3BaDKHZG2baCwQoREVECMtK2FfoLn4iIiEhRRtu2gsEKERFRAjHithUMVoiIiBKIEbetYLBCRESUQIy4bQWDFSIiogRixG0rGKwQERElECNuW8FghYiISKcEwYfujkZ0tu5Gd0ejLEmvRty2gnVWiIiIdEjJOij+bSsG/v4kWw6cpTW6q7NiEgRB0LoRQ3G73XA4HHC5XMjMzNS6OURERIry10EJR659sJSuYCtX/82RFSIiIh0RWwclPaci5sDCKNtW6GdCioiIiAxZB0VpDFaIiIh0xIh1UJTGYIWIiEhHjFgHRWkMVoiIiHTEiHVQlMZghYiISEeMWAdFaYnzSomIiAzCXwdl4AhLki1HtmXLRsKly0RERDpkd1YiPadC0TooRsFghYiISKeMUgdFaYkXnhEREZGhMFghIiIiXWOwQkRERLrGYIWIiIh0jcEKERER6RqDFSIiItI1BitERESkawxWiIiISNcYrBAREZGuGaKCrSAIAAC3261xS4iIiEgsf7/t78ejZYhg5eTJkwCA4uJijVtCREREUnV2dsLhcER9viGClezs87tOHj16NKYXS7Fzu90oLi7GsWPHkJmZqXVzEhavg37wWugDr4N+9L8WGRkZ6OzsRFFRUUy/0xDBitl8PrXG4XDwQ6gTmZmZvBY6wOugH7wW+sDroB/+ayHHIAMTbImIiEjXGKwQERGRrhkiWLHZbFiyZAlsNpvWTUl4vBb6wOugH7wW+sDroB9KXAuTEOt6IiIiIiIFGWJkhYiIiBIXgxUiIiLSNQYrREREpGsMVoiIiEjXdBOsrF+/HiUlJUhJScGECRPQ0NAQ8fjf/e53uPTSS5GSkoLLL78c27dvV6ml8U/KtXjuuedw7bXXYtiwYRg2bBiqq6uHvHYkjtS/Cb8tW7bAZDJhypQpyjYwgUi9Fh0dHZg7dy4KCwths9lQVlbG7ygZSL0Oa9euxahRo5Camori4mLMnz8fZ8+eVam18ekvf/kLJk+ejKKiIphMJrz66qtDnrNr1y6MGzcONpsNF198Merq6qQ/saADW7ZsEaxWq/D8888LjY2Nwpw5c4SsrCyhpaUl5PG7d+8WLBaL8NhjjwkfffSR8PDDDwvJycnCBx98oHLL44/UazFt2jRh/fr1wnvvvSc0NTUJs2bNEhwOh/Dpp5+q3PL4IvU6+B0+fFgYPny4cO211wrf+c531GlsnJN6LXp6eoSKigrhhhtuEN566y3h8OHDwq5du4R9+/ap3PL4IvU6vPDCC4LNZhNeeOEF4fDhw8Ibb7whFBYWCvPnz1e55fFl+/btwkMPPSS88sorAgBh69atEY8/dOiQkJaWJtTW1gofffSRsG7dOsFisQg7duyQ9Ly6CFYqKyuFuXPnBv7t9XqFoqIiYeXKlSGPv/XWW4Ubb7wx6LEJEyYIP/zhDxVtZyKQei0G6uvrEzIyMoTNmzcr1cSEEM116OvrE66++mrhl7/8pVBTU8NgRSZSr8WGDRuE0tJSobe3V60mJgSp12Hu3LnC1772taDHamtrhaqqKkXbmUjEBCv333+/MHr06KDHpk6dKkyaNEnSc2k+DdTb24u9e/eiuro68JjZbEZ1dTX27NkT8pw9e/YEHQ8AkyZNCns8iRPNtRiou7sb586dC2w+SdJFex1+9rOfIS8vD7fffrsazUwI0VyLP/zhD5g4cSLmzp2L/Px8fOlLX8KKFSvg9XrVanbcieY6XH311di7d29gqujQoUPYvn07brjhBlXaTOfJ1V9rvpFhe3s7vF4v8vPzgx7Pz8/H/v37Q57T3Nwc8vjm5mbF2pkIorkWAz3wwAMoKioa9OEk8aK5Dm+99RZ+9atfYd++fSq0MHFEcy0OHTqE//3f/8X06dOxfft2/Otf/8KPfvQjnDt3DkuWLFGj2XEnmuswbdo0tLe345prroEgCOjr68Ndd92Fn/70p2o0mT4Xrr92u904c+YMUlNTRf0ezUdWKH6sWrUKW7ZswdatW5GSkqJ1cxJGZ2cnZsyYgeeeew5Op1Pr5iQ8n8+HvLw8PPvssxg/fjymTp2Khx56CBs3btS6aQll165dWLFiBZ5++mm8++67eOWVV7Bt2zYsW7ZM66ZRFDQfWXE6nbBYLGhpaQl6vKWlBQUFBSHPKSgokHQ8iRPNtfBbvXo1Vq1ahTfffBNXXHGFks2Me1Kvw8GDB3HkyBFMnjw58JjP5wMAJCUl4cCBAxg5cqSyjY5T0fxNFBYWIjk5GRaLJfBYeXk5mpub0dvbC6vVqmib41E012HRokWYMWMG7rjjDgDA5Zdfjq6uLtx555146KGHYDbzXl0N4frrzMxM0aMqgA5GVqxWK8aPH4/6+vrAYz6fD/X19Zg4cWLIcyZOnBh0PADs3Lkz7PEkTjTXAgAee+wxLFu2DDt27EBFRYUaTY1rUq/DpZdeig8++AD79u0L/Hz729/Gddddh3379qG4uFjN5seVaP4mqqqq8K9//SsQMALAxx9/jMLCQgYqUYrmOnR3dw8KSPwBpMAt8VQjW38tLfdXGVu2bBFsNptQV1cnfPTRR8Kdd94pZGVlCc3NzYIgCMKMGTOEBx98MHD87t27haSkJGH16tVCU1OTsGTJEi5dlonUa7Fq1SrBarUKL7/8snDixInAT2dnp1YvIS5IvQ4DcTWQfKRei6NHjwoZGRnCvHnzhAMHDgivvfaakJeXJzz66KNavYS4IPU6LFmyRMjIyBD++7//Wzh06JDwpz/9SRg5cqRw6623avUS4kJnZ6fw3nvvCe+9954AQFizZo3w3nvvCZ988okgCILw4IMPCjNmzAgc71+6vGDBAqGpqUlYv369cZcuC4IgrFu3TrjwwgsFq9UqVFZWCn/7298C//eVr3xFqKmpCTr+t7/9rVBWViZYrVZh9OjRwrZt21RucfySci1GjBghABj0s2TJEvUbHmek/k30x2BFXlKvxdtvvy1MmDBBsNlsQmlpqbB8+XKhr69P5VbHHynX4dy5c8IjjzwijBw5UkhJSRGKi4uFH/3oR8Lp06fVb3gc+fOf/xzyO9//3tfU1Ahf+cpXBp0zZswYwWq1CqWlpcKmTZskP69JEDgeRkRERPqlec4KERERUSQMVoiIiEjXGKwQERGRrjFYISIiIl1jsEJERES6xmCFiIiIdI3BChEREekagxUiIiLSNQYrREREpGsMVoiIiEjXGKwQERGRrjFYISIiIl37/1rzpLeSv+y6AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# And then visualize the results\n", + "candidate_positions = np.array([i for i in candidate_position_dict.values()])\n", + "pal = sns.color_palette(\"hls\", 8)\n", + "plt.scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "plt.scatter(candidate_positions[:,0], candidate_positions[:,1], label = 'candidates', color = pal[1])\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "08d68a71-5ce2-4c76-8b0a-3eb008eee07e", + "metadata": {}, + "outputs": [], + "source": [ + "# In another setting, we may imagine that voters are \n", + "# normally distributed around each of the candidates\n", + "\n", + "# Like before we'll have a candidate distribution. \n", + "# For now, just use the same Uniform(0,1) in 2d\n", + "candidate_params = {'low': 0, 'high': 1, 'size': 2}\n", + "\n", + "# And stick to euclidean distance\n", + "distance = lambda point1, point2: np.linalg.norm(point1 - point2)\n", + "\n", + "# But now, for each candidate, we'll assign to them a certain \n", + "# number of voters. Let's evenly distribute voters amongst candidates\n", + "ballots_per = {c: n//m for c in candidates}\n", + "\n", + "# Those voters will be normally distributed around their candidate\n", + "# i.e. the mean of their normal distribution is at the candidate. \n", + "# And we'll give them the remaining parmaters:\n", + "voter_params = {'scale': 0.1, 'size': 2}\n", + "\n", + "# Now we may pass all of to the DSpatial generation method\n", + "generator = Clustered_DSpatial(candidates = candidates,\n", + " voter_dist = np.random.normal, voter_params = voter_params,\n", + " candidate_dist = np.random.uniform, candidate_params = candidate_params,\n", + " distance = distance)\n", + "\n", + "# And generate a profile from random candidate and voter positions\n", + "profile, candidate_position_dict, voter_positions = generator.generate_profile_with_dict(number_of_ballots = ballots_per, seed = None)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "889bc17c-677d-41c9-ba75-84eaddf8907f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# And then visualize the results\n", + "candidate_positions = np.array([i for i in candidate_position_dict.values()])\n", + "pal = sns.color_palette(\"hls\", 8)\n", + "plt.scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "plt.scatter(candidate_positions[:,0], candidate_positions[:,1], label = 'candidates', color = pal[1])\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "7933cc51-a9a8-4583-944f-208cd5beec84", + "metadata": {}, + "source": [ + "# Elections in Metric Settings" + ] + }, + { + "cell_type": "markdown", + "id": "4603d2a8-3503-4247-934f-ab8ae31be929", + "metadata": {}, + "source": [ + "Suppose voters and candidates occupy positions in a metric space and an election mechanism \n", + "$M$ decides on a winner set by looking at the ranked ballots. In this section we \n", + "compare the location in the metric space of the winning candidates. \n", + "We take inspiration and recreate some examples from [Elkind et al 2019](https://arxiv.org/abs/1901.09217)." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "abfed563-b9b1-4ed5-82ea-e554ba904bb2", + "metadata": {}, + "outputs": [], + "source": [ + "# Choose number of voters n\n", + "# And the number of candidates m\n", + "n = 200\n", + "m = 200\n", + "candidates = [str(i) for i in range(m)]\n", + "\n", + "# And the number of winners for the election\n", + "k = 20 " + ] + }, + { + "cell_type": "markdown", + "id": "205e9c52-3cb2-4e41-977b-3b01d3ef38e8", + "metadata": {}, + "source": [ + "## Gaussian Generation" + ] + }, + { + "cell_type": "markdown", + "id": "bd1eb6cf-263a-42e4-b56f-5e1fa5bdddec", + "metadata": {}, + "source": [ + "Here voters and vandidates are both drawn from the $\\sim \\text{Normal}(0,1)$ distribution. " + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "819a5796-a855-4561-8162-0cb3f5a0a2d4", + "metadata": {}, + "outputs": [], + "source": [ + "voter_params = {'loc': 0, 'scale': 1, 'size': 2}\n", + "candidate_params = {'loc': 0, 'scale': 1, 'size': 2}\n", + "distance = lambda point1, point2: np.linalg.norm(point1 - point2)\n", + "\n", + "generator = DSpatial(candidates = candidates,\n", + " voter_dist = np.random.normal, voter_params = voter_params,\n", + " candidate_dist = np.random.normal, candidate_params = candidate_params,\n", + " distance = distance)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "5d6bb6bd-a3a2-4c3e-8f88-2d2b15b1a15d", + "metadata": {}, + "outputs": [], + "source": [ + "# Generate a profile from random candidate and voter positions\n", + "profile, candidate_position_dict, voter_positions = generator.generate_profile(number_of_ballots = n, seed = None)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "1e46f9d5-5d0d-4cdf-be6f-1d3e065de170", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# visualize the results\n", + "candidate_positions = np.array([i for i in candidate_position_dict.values()])\n", + "pal = sns.color_palette(\"hls\", 8)\n", + "plt.scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "plt.scatter(candidate_positions[:,0], candidate_positions[:,1], label = 'candidates', color = pal[1])\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "9c156efb-ff85-407e-b4d3-203f5bf61a42", + "metadata": {}, + "source": [ + "### Elections" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "9d53fb8f-603c-4ffb-9443-d7c9d6bc3c77", + "metadata": {}, + "outputs": [], + "source": [ + "# Now run a few different election mechanisms on the profile generated above \n", + "# to decide on a winner set. \n", + "\n", + "# SNTV\n", + "sntv_election = SNTV(profile, k)\n", + "sntv_results = sntv_election.run_election()\n", + "sntv_winners = [int(list(i)[0]) for i in sntv_results.winners()]\n", + "\n", + "# STV\n", + "stv_election = STV(profile, fractional_transfer, k, quota = 'droop')\n", + "stv_results = stv_election.run_election()\n", + "stv_winners = [int(list(i)[0]) for i in stv_results.winners()]\n", + "\n", + "# k-Borda\n", + "borda_election = Borda(profile, k)\n", + "borda_results = borda_election.run_election()\n", + "borda_winners = [int(list(i)[0]) for i in borda_results.winners()]\n", + "\n", + "# k-Random Dictator\n", + "random_election = RandomDictator(profile, k)\n", + "random_results = random_election.run_election()\n", + "random_winners = [int(list(i)[0]) for i in random_results.winners()]\n", + "\n", + "# k-Boosted Random Dictator\n", + "boosted_random_election = BoostedRandomDictator(profile, k)\n", + "boosted_random_results = boosted_random_election.run_election()\n", + "boosted_random_winners = [int(list(i)[0]) for i in boosted_random_results.winners()]\n", + "\n", + "# k-Plurality Veto\n", + "plurality_veto_election = PluralityVeto(profile, k)\n", + "plurality_veto_results = plurality_veto_election.run_election()\n", + "plurality_veto_winners = [int(list(i)[0]) for i in plurality_veto_results.winners()]" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "11feb62c-4d96-4752-966c-9dc20497a8e4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Plurality Veto')" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 3, figsize=(14, 10)) \n", + "\n", + "axes[0][0].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[0][0].scatter(candidate_positions[sntv_winners,0], candidate_positions[sntv_winners,1], label = 'winners', color = pal[1])\n", + "axes[0][0].set_title('SNTV')\n", + "axes[0][0].legend()\n", + "\n", + "axes[0][1].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[0][1].scatter(candidate_positions[stv_winners,0], candidate_positions[stv_winners,1], label = 'winners', color = pal[1])\n", + "axes[0][1].set_title('STV')\n", + "\n", + "axes[0][2].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[0][2].scatter(candidate_positions[borda_winners,0], candidate_positions[borda_winners,1], label = 'winners', color = pal[1])\n", + "axes[0][2].set_title('Borda')\n", + "\n", + "axes[1][0].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[1][0].scatter(candidate_positions[random_winners,0], candidate_positions[random_winners,1], label = 'winners', color = pal[1])\n", + "axes[1][0].set_title('Random Dictator')\n", + "\n", + "axes[1][1].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[1][1].scatter(candidate_positions[boosted_random_winners,0], candidate_positions[boosted_random_winners,1], label = 'winners', color = pal[1])\n", + "axes[1][1].set_title('Boosted Random Dictator')\n", + "\n", + "axes[1][2].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[1][2].scatter(candidate_positions[plurality_veto_winners,0], candidate_positions[plurality_veto_winners,1], label = 'winners', color = pal[1])\n", + "axes[1][2].set_title('Plurality Veto')" + ] + }, + { + "cell_type": "markdown", + "id": "cec15dd0-a1c8-4db2-9174-8213d810af62", + "metadata": {}, + "source": [ + "## Uniform Disc Generation" + ] + }, + { + "cell_type": "markdown", + "id": "b6aefcde-c2ae-42f5-8659-01b0ba56f823", + "metadata": {}, + "source": [ + "In this example, both voter and candidate positions are sampled \n", + "the uniform disc distribution, which uniformly draws points from a sphere of radius 1 centered at the origin. " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "cf15175c-7d75-46ec-b98e-de18bd6798b0", + "metadata": {}, + "outputs": [], + "source": [ + "# samples a single point uniformly from a disc with defined radius\n", + "def sample_uniform_disc(radius=1):\n", + " # Sample angles uniformly from 0 to 2*pi\n", + " theta = np.random.uniform(0, 2 * np.pi, 1)\n", + " \n", + " # Sample radii with correct distribution\n", + " r = radius * np.sqrt(np.random.uniform(0, 1, 1))\n", + " \n", + " # Convert polar coordinates to Cartesian coordinates\n", + " x = r * np.cos(theta)\n", + " y = r * np.sin(theta)\n", + " return np.column_stack((x, y))[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "5f4ec611-9518-4581-9f41-fb9c46a5feef", + "metadata": {}, + "outputs": [], + "source": [ + "voter_params = {'radius': 1}\n", + "candidate_params = {'radius': 1}\n", + "distance = lambda point1, point2: np.linalg.norm(point1 - point2)\n", + "\n", + "generator = DSpatial(candidates = candidates,\n", + " voter_dist = sample_uniform_disc, voter_params = voter_params,\n", + " candidate_dist = sample_uniform_disc, candidate_params = candidate_params,\n", + " distance = distance)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "4b864a18-2aaf-43f9-9682-f0fccd37f17d", + "metadata": {}, + "outputs": [], + "source": [ + "# Generate a profile from random candidate and voter positions\n", + "profile, candidate_position_dict, voter_positions = generator.generate_profile(number_of_ballots = n, seed = None)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "540f1a72-f850-4ddd-81e8-babb3593fed4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# visualize the results\n", + "candidate_positions = np.array([i for i in candidate_position_dict.values()])\n", + "pal = sns.color_palette(\"hls\", 8)\n", + "plt.scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "plt.scatter(candidate_positions[:,0], candidate_positions[:,1], label = 'candidates', color = pal[1])\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "f412b3c9-4075-49c4-a5df-4c1983335a0d", + "metadata": {}, + "source": [ + "### Elections" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "e56cf423-c7eb-4206-bf50-8c8740a8ac78", + "metadata": {}, + "outputs": [], + "source": [ + "# SNTV\n", + "sntv_election = SNTV(profile, k)\n", + "sntv_results = sntv_election.run_election()\n", + "sntv_winners = [int(list(i)[0]) for i in sntv_results.winners()]\n", + "\n", + "# STV\n", + "stv_election = STV(profile, fractional_transfer, k, quota = 'droop')\n", + "stv_results = stv_election.run_election()\n", + "stv_winners = [int(list(i)[0]) for i in stv_results.winners()]\n", + "\n", + "# k-Borda\n", + "borda_election = Borda(profile, k)\n", + "borda_results = borda_election.run_election()\n", + "borda_winners = [int(list(i)[0]) for i in borda_results.winners()]\n", + "\n", + "# k-Random Dictator\n", + "random_election = RandomDictator(profile, k)\n", + "random_results = random_election.run_election()\n", + "random_winners = [int(list(i)[0]) for i in random_results.winners()]\n", + "\n", + "# k-Boosted Random Dictator\n", + "boosted_random_election = BoostedRandomDictator(profile, k)\n", + "boosted_random_results = boosted_random_election.run_election()\n", + "boosted_random_winners = [int(list(i)[0]) for i in boosted_random_results.winners()]\n", + "\n", + "# k-Plurality Veto\n", + "plurality_veto_election = PluralityVeto(profile, k)\n", + "plurality_veto_results = plurality_veto_election.run_election()\n", + "plurality_veto_winners = [int(list(i)[0]) for i in plurality_veto_results.winners()]" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "182010fe-91c5-4e92-a804-e95c8dac6eb3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Plurality Veto')" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 3, figsize=(14, 10)) \n", + "\n", + "axes[0][0].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[0][0].scatter(candidate_positions[sntv_winners,0], candidate_positions[sntv_winners,1], label = 'winners', color = pal[1])\n", + "axes[0][0].set_title('SNTV')\n", + "axes[0][0].legend()\n", + "\n", + "axes[0][1].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[0][1].scatter(candidate_positions[stv_winners,0], candidate_positions[stv_winners,1], label = 'winners', color = pal[1])\n", + "axes[0][1].set_title('STV')\n", + "\n", + "axes[0][2].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[0][2].scatter(candidate_positions[borda_winners,0], candidate_positions[borda_winners,1], label = 'winners', color = pal[1])\n", + "axes[0][2].set_title('Borda')\n", + "\n", + "axes[1][0].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[1][0].scatter(candidate_positions[random_winners,0], candidate_positions[random_winners,1], label = 'winners', color = pal[1])\n", + "axes[1][0].set_title('Random Dictator')\n", + "\n", + "axes[1][1].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[1][1].scatter(candidate_positions[boosted_random_winners,0], candidate_positions[boosted_random_winners,1], label = 'winners', color = pal[1])\n", + "axes[1][1].set_title('Boosted Random Dictator')\n", + "\n", + "axes[1][2].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[1][2].scatter(candidate_positions[plurality_veto_winners,0], candidate_positions[plurality_veto_winners,1], label = 'winners', color = pal[1])\n", + "axes[1][2].set_title('Plurality Veto')" + ] + }, + { + "cell_type": "markdown", + "id": "b0f50c5a-0315-455f-8b9e-226ffd121ba4", + "metadata": {}, + "source": [ + "## Uniform Square Generation" + ] + }, + { + "cell_type": "markdown", + "id": "875c8fa8-6596-4f4b-90b6-df0a8fb7d66f", + "metadata": {}, + "source": [ + "Here voters and candidates both follow the $\\sim \\text{Uniform}(0,1)$ distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "51bc06fe-6f54-457d-9911-689e33ff0250", + "metadata": {}, + "outputs": [], + "source": [ + "voter_params = {'low': 0, 'high': 1, 'size': 2}\n", + "candidate_params = {'low': 0, 'high': 1, 'size': 2}\n", + "distance = lambda point1, point2: np.linalg.norm(point1 - point2)\n", + "\n", + "generator = DSpatial(candidates = candidates,\n", + " voter_dist = np.random.uniform, voter_params = voter_params,\n", + " candidate_dist = np.random.uniform, candidate_params = candidate_params,\n", + " distance = distance)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "7b105e9a-8516-4772-9cfa-059ee8400a4c", + "metadata": {}, + "outputs": [], + "source": [ + "# Generate a profile from random candidate and voter positions\n", + "profile, candidate_position_dict, voter_positions = generator.generate_profile(number_of_ballots = n, seed = None)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "ff62155d-a5eb-4128-8aa6-166fe4012a28", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# visualize the results\n", + "candidate_positions = np.array([i for i in candidate_position_dict.values()])\n", + "pal = sns.color_palette(\"hls\", 8)\n", + "plt.scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "plt.scatter(candidate_positions[:,0], candidate_positions[:,1], label = 'candidates', color = pal[1])\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "d4e45df2-6957-47ef-9207-9584b2057d4b", + "metadata": {}, + "source": [ + "### Elections" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "a88d67f6-ebfa-4eaf-9645-c869c55a1e41", + "metadata": {}, + "outputs": [], + "source": [ + "# SNTV\n", + "sntv_election = SNTV(profile, k)\n", + "sntv_results = sntv_election.run_election()\n", + "sntv_winners = [int(list(i)[0]) for i in sntv_results.winners()]\n", + "\n", + "# STV\n", + "stv_election = STV(profile, fractional_transfer, k, quota = 'droop')\n", + "stv_results = stv_election.run_election()\n", + "stv_winners = [int(list(i)[0]) for i in stv_results.winners()]\n", + "\n", + "# k-Borda\n", + "borda_election = Borda(profile, k)\n", + "borda_results = borda_election.run_election()\n", + "borda_winners = [int(list(i)[0]) for i in borda_results.winners()]\n", + "\n", + "# k-Random Dictator\n", + "random_election = RandomDictator(profile, k)\n", + "random_results = random_election.run_election()\n", + "random_winners = [int(list(i)[0]) for i in random_results.winners()]\n", + "\n", + "# k-Boosted Random Dictator\n", + "boosted_random_election = BoostedRandomDictator(profile, k)\n", + "boosted_random_results = boosted_random_election.run_election()\n", + "boosted_random_winners = [int(list(i)[0]) for i in boosted_random_results.winners()]\n", + "\n", + "# k-Plurality Veto\n", + "plurality_veto_election = PluralityVeto(profile, k)\n", + "plurality_veto_results = plurality_veto_election.run_election()\n", + "plurality_veto_winners = [int(list(i)[0]) for i in plurality_veto_results.winners()]" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "cb204e7f-91d6-401a-a1e6-5f8f5089e319", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Plurality Veto')" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 3, figsize=(14, 10)) \n", + "\n", + "axes[0][0].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[0][0].scatter(candidate_positions[sntv_winners,0], candidate_positions[sntv_winners,1], label = 'winners', color = pal[1])\n", + "axes[0][0].set_title('SNTV')\n", + "axes[0][0].legend()\n", + "\n", + "axes[0][1].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[0][1].scatter(candidate_positions[stv_winners,0], candidate_positions[stv_winners,1], label = 'winners', color = pal[1])\n", + "axes[0][1].set_title('STV')\n", + "\n", + "axes[0][2].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[0][2].scatter(candidate_positions[borda_winners,0], candidate_positions[borda_winners,1], label = 'winners', color = pal[1])\n", + "axes[0][2].set_title('Borda')\n", + "\n", + "axes[1][0].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[1][0].scatter(candidate_positions[random_winners,0], candidate_positions[random_winners,1], label = 'winners', color = pal[1])\n", + "axes[1][0].set_title('Random Dictator')\n", + "\n", + "axes[1][1].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[1][1].scatter(candidate_positions[boosted_random_winners,0], candidate_positions[boosted_random_winners,1], label = 'winners', color = pal[1])\n", + "axes[1][1].set_title('Boosted Random Dictator')\n", + "\n", + "axes[1][2].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[1][2].scatter(candidate_positions[plurality_veto_winners,0], candidate_positions[plurality_veto_winners,1], label = 'winners', color = pal[1])\n", + "axes[1][2].set_title('Plurality Veto')" + ] + }, + { + "cell_type": "markdown", + "id": "74cb0c1b-2553-46c4-91dc-92ac03619a72", + "metadata": {}, + "source": [ + "## 4-Gaussian Generation" + ] + }, + { + "cell_type": "markdown", + "id": "8ae364f3-8e2a-49c1-8101-ea67d4f1a52d", + "metadata": {}, + "source": [ + "Finally in this example voters are sampled from a multimodal gaussian distribution with 4 centers -- representing 4 different parties. Candidates are sampled from the $\\sim \\text{uniform}(-3,3)$ distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "1338b9c4-35f9-4cd8-b6f3-e890cde6b9ff", + "metadata": {}, + "outputs": [], + "source": [ + "# samples a single point from mixture of gaussians\n", + "def sample_from_mixture(means, stds, weights):\n", + " # Ensure the weights sum to 1\n", + " weights = np.array(weights)\n", + " weights /= weights.sum()\n", + " \n", + " # Choose one of the distributions based on the weights\n", + " distribution_index = np.random.choice(len(means), p=weights)\n", + " \n", + " # Sample a point from the chosen distribution\n", + " mean = means[distribution_index]\n", + " std = stds[distribution_index]\n", + " point = np.random.normal(loc=mean, scale=std, size=(2,))\n", + " \n", + " return point" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "fe7bcfbd-823f-4c37-a3cf-1a9cba82aa6d", + "metadata": {}, + "outputs": [], + "source": [ + "# Means for each of the 4 Gaussian distributions\n", + "means = [(-2, -2), (2, -2), (-2, 2), (2, 2)]\n", + "stds = [0.5, 0.5, 0.5, 0.5] # Standard deviations for each Gaussian\n", + "weights = [0.25, 0.25, 0.25, 0.25] # Weights for each Gaussian\n", + "\n", + "voter_params = {'means': means, 'stds': stds, 'weights': weights}\n", + "#candidate_params = {'means': means, 'stds': stds, 'weights': weights}\n", + "candidate_params = {'low': -3, 'high': 3, 'size': 2}\n", + "\n", + "distance = lambda point1, point2: np.linalg.norm(point1 - point2)\n", + "\n", + "generator = DSpatial(candidates = candidates,\n", + " voter_dist = sample_from_mixture, voter_params = voter_params,\n", + " candidate_dist = np.random.uniform, candidate_params = candidate_params,\n", + " distance = distance)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "6e0e6c6b-2fd3-4abb-8be3-c67d9e3fc378", + "metadata": {}, + "outputs": [], + "source": [ + "# Generate a profile from random candidate and voter positions\n", + "profile, candidate_position_dict, voter_positions = generator.generate_profile(number_of_ballots = n, seed = None)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "d389d837-7410-41c7-9300-b3a77e78e06d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# visualize the results\n", + "candidate_positions = np.array([i for i in candidate_position_dict.values()])\n", + "pal = sns.color_palette(\"hls\", 8)\n", + "plt.scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "plt.scatter(candidate_positions[:,0], candidate_positions[:,1], label = 'candidates', color = pal[1])\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "7b15161e-7932-44d2-b9ac-54b3e7ba66d7", + "metadata": {}, + "source": [ + "### Elections" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "33ab5c6b-3548-4ebb-88a2-2c15fc3da871", + "metadata": {}, + "outputs": [], + "source": [ + "# SNTV\n", + "sntv_election = SNTV(profile, k)\n", + "sntv_results = sntv_election.run_election()\n", + "sntv_winners = [int(list(i)[0]) for i in sntv_results.winners()]\n", + "\n", + "# STV\n", + "stv_election = STV(profile, fractional_transfer, k, quota = 'droop')\n", + "stv_results = stv_election.run_election()\n", + "stv_winners = [int(list(i)[0]) for i in stv_results.winners()]\n", + "\n", + "# k-Borda\n", + "borda_election = Borda(profile, k)\n", + "borda_results = borda_election.run_election()\n", + "borda_winners = [int(list(i)[0]) for i in borda_results.winners()]\n", + "\n", + "# k-Random Dictator\n", + "random_election = RandomDictator(profile, k)\n", + "random_results = random_election.run_election()\n", + "random_winners = [int(list(i)[0]) for i in random_results.winners()]\n", + "\n", + "# k-Boosted Random Dictator\n", + "boosted_random_election = BoostedRandomDictator(profile, k)\n", + "boosted_random_results = boosted_random_election.run_election()\n", + "boosted_random_winners = [int(list(i)[0]) for i in boosted_random_results.winners()]\n", + "\n", + "# k-Plurality Veto\n", + "plurality_veto_election = PluralityVeto(profile, k)\n", + "plurality_veto_results = plurality_veto_election.run_election()\n", + "plurality_veto_winners = [int(list(i)[0]) for i in plurality_veto_results.winners()]" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "0023996b-c073-4df1-bd21-6cd880f6f5cb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Plurality Veto')" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 3, figsize=(14, 10)) \n", + "\n", + "axes[0][0].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[0][0].scatter(candidate_positions[sntv_winners,0], candidate_positions[sntv_winners,1], label = 'winners', color = pal[1])\n", + "axes[0][0].set_title('SNTV')\n", + "axes[0][0].legend()\n", + "\n", + "axes[0][1].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[0][1].scatter(candidate_positions[stv_winners,0], candidate_positions[stv_winners,1], label = 'winners', color = pal[1])\n", + "axes[0][1].set_title('STV')\n", + "\n", + "axes[0][2].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[0][2].scatter(candidate_positions[borda_winners,0], candidate_positions[borda_winners,1], label = 'winners', color = pal[1])\n", + "axes[0][2].set_title('Borda')\n", + "\n", + "axes[1][0].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[1][0].scatter(candidate_positions[random_winners,0], candidate_positions[random_winners,1], label = 'winners', color = pal[1])\n", + "axes[1][0].set_title('Random Dictator')\n", + "\n", + "axes[1][1].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[1][1].scatter(candidate_positions[boosted_random_winners,0], candidate_positions[boosted_random_winners,1], label = 'winners', color = pal[1])\n", + "axes[1][1].set_title('Boosted Random Dictator')\n", + "\n", + "axes[1][2].scatter(voter_positions[:,0], voter_positions[:,1], label = 'voters', color = pal[4])\n", + "axes[1][2].scatter(candidate_positions[plurality_veto_winners,0], candidate_positions[plurality_veto_winners,1], label = 'winners', color = pal[1])\n", + "axes[1][2].set_title('Plurality Veto')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "vote", + "language": "python", + "name": "vote" + }, + "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.9.19" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/votekit/ballot_generator.py b/src/votekit/ballot_generator.py index 9dc4c2c..cf2a43e 100644 --- a/src/votekit/ballot_generator.py +++ b/src/votekit/ballot_generator.py @@ -2068,7 +2068,7 @@ class Clustered_DSpatial(BallotGenerator): Clustered spatial model for ballot generation. In some metric space determined by an input distance function, randomly sample each candidate's positions from input candidate distribution. Then - sample voters's positions from normal distributions centered around each + sample voters's positions from a distribution centered around each of the candidate's positions. Using generate_profile() outputs a ranked profile which is consistent with the sampled positions (respects distances). @@ -2076,7 +2076,7 @@ class Clustered_DSpatial(BallotGenerator): Args: candidates (list[str]): List of candidate strings. voter_dist (Callable[..., np.ndarray], optional): Distribution to sample a single - voter's position from, defaults to uniform distribution. + voter's position from, defaults to normal(0,1) distribution. voter_params: (Optional[dict[str, Any]], optional): Parameters to be passed to voter_dist, defaults to None, which creates the unif(0,1) distribution in 2 dimensions. candidate_dist: (Callable[..., np.ndarray], optional): Distribution to sample a @@ -2106,7 +2106,7 @@ class Clustered_DSpatial(BallotGenerator): def __init__( self, candidates: list[str], - voter_dist: Callable[..., np.ndarray] = np.random.uniform, + voter_dist: Callable[..., np.ndarray] = np.random.normal, voter_params: Optional[Dict[str, Any]] = None, candidate_dist: Callable[..., np.ndarray] = np.random.uniform, candidate_params: Optional[Dict[str, Any]] = None, @@ -2114,11 +2114,21 @@ def __init__( ): super().__init__(candidates=candidates) self.candidate_dist = candidate_dist + self.voter_dist = voter_dist if voter_params is None: # default params used for np.random.normal - self.voter_params = {"std": np.array(1.0), "size": np.array(2.0)} + self.voter_params = {"loc": 0, "std": np.array(1.0), "size": np.array(2.0)} else: + # Trying to ensure that the input distribution's mean is parameterized. + # This allows me to center it on the candidates themselves later + try: + voter_params['loc'] = 0 + self.voter_dist(**voter_params) + except TypeError: + raise ValueError("Invalid parameters for the voter distribution, make sure\ + that the input distribution has a 'loc' parameter specifying the mean.") + self.voter_params = voter_params if candidate_params is None: @@ -2130,7 +2140,7 @@ def __init__( self.distance = distance def generate_profile_with_dict( - self, number_of_ballots: dict, by_bloc: bool = False, seed: Optional[int] = None + self, number_of_ballots: dict[str,int], by_bloc: bool = False, seed: Optional[int] = None ) -> Union[PreferenceProfile, Tuple]: """ Args: @@ -2158,11 +2168,8 @@ def generate_profile_with_dict( voter_positions = [] for c in self.candidates: for v in range(number_of_ballots[c]): - voter_positions.append( - np.random.normal( - loc=candidate_position_dict[c], **self.voter_params - ) - ) + self.voter_params['loc'] = candidate_position_dict[c] + voter_positions.append(self.voter_dist(**self.voter_params)) voter_positions_array = np.vstack(voter_positions) From 8f5fb59dc59b1dc3f89e972fcaa6a9335f586614 Mon Sep 17 00:00:00 2001 From: Kevin Quinn Date: Thu, 8 Aug 2024 01:26:26 -0400 Subject: [PATCH 05/16] cleanup --- notebooks/6_metric_voting.ipynb | 31 ++- src/votekit/ballot_generator.py | 167 ++++++++++----- src/votekit/elections/election_types.py | 273 ++++++++++++------------ src/votekit/metrics/distances.py | 2 +- tests/test_bg_errors.py | 155 +++++++++++++- 5 files changed, 422 insertions(+), 206 deletions(-) diff --git a/notebooks/6_metric_voting.ipynb b/notebooks/6_metric_voting.ipynb index b3d2e40..da18a2c 100755 --- a/notebooks/6_metric_voting.ipynb +++ b/notebooks/6_metric_voting.ipynb @@ -26,8 +26,7 @@ "\n", "from votekit.pref_profile import PreferenceProfile\n", "from votekit.ballot import Ballot\n", - "from votekit.ballot_generator import DSpatial\n", - "from votekit.ballot_generator import Clustered_DSpatial\n", + "from votekit.ballot_generator import Spatial, ClusteredSpatial\n", "from votekit.elections import SNTV, STV, Borda, RandomDictator, BoostedRandomDictator, PluralityVeto, fractional_transfer" ] }, @@ -89,14 +88,14 @@ "# Here, we just use euclidean distance\n", "distance = lambda point1, point2: np.linalg.norm(point1 - point2)\n", "\n", - "# Now we may pass all of to the DSpatial generation method\n", - "generator = DSpatial(candidates = candidates,\n", + "# Now we may pass all of to the Spatial generation method\n", + "generator = Spatial(candidates = candidates,\n", " voter_dist = np.random.normal, voter_params = voter_params,\n", " candidate_dist = np.random.uniform, candidate_params = candidate_params,\n", " distance = distance)\n", "\n", "# Generate a profile from random candidate and voter positions\n", - "profile, candidate_position_dict, voter_positions = generator.generate_profile(number_of_ballots = n, seed = None)" + "profile, candidate_position_dict, voter_positions = generator.generate_profile(number_of_ballots = n)" ] }, { @@ -161,14 +160,14 @@ "# And we'll give them the remaining parmaters:\n", "voter_params = {'scale': 0.1, 'size': 2}\n", "\n", - "# Now we may pass all of to the DSpatial generation method\n", - "generator = Clustered_DSpatial(candidates = candidates,\n", + "# Now we may pass all of to the Spatial generation method\n", + "generator = ClusteredSpatial(candidates = candidates,\n", " voter_dist = np.random.normal, voter_params = voter_params,\n", " candidate_dist = np.random.uniform, candidate_params = candidate_params,\n", " distance = distance)\n", "\n", "# And generate a profile from random candidate and voter positions\n", - "profile, candidate_position_dict, voter_positions = generator.generate_profile_with_dict(number_of_ballots = ballots_per, seed = None)" + "profile, candidate_position_dict, voter_positions = generator.generate_profile_with_dict(number_of_ballots = ballots_per)" ] }, { @@ -270,7 +269,7 @@ "candidate_params = {'loc': 0, 'scale': 1, 'size': 2}\n", "distance = lambda point1, point2: np.linalg.norm(point1 - point2)\n", "\n", - "generator = DSpatial(candidates = candidates,\n", + "generator = Spatial(candidates = candidates,\n", " voter_dist = np.random.normal, voter_params = voter_params,\n", " candidate_dist = np.random.normal, candidate_params = candidate_params,\n", " distance = distance)" @@ -284,7 +283,7 @@ "outputs": [], "source": [ "# Generate a profile from random candidate and voter positions\n", - "profile, candidate_position_dict, voter_positions = generator.generate_profile(number_of_ballots = n, seed = None)" + "profile, candidate_position_dict, voter_positions = generator.generate_profile(number_of_ballots = n)" ] }, { @@ -477,7 +476,7 @@ "candidate_params = {'radius': 1}\n", "distance = lambda point1, point2: np.linalg.norm(point1 - point2)\n", "\n", - "generator = DSpatial(candidates = candidates,\n", + "generator = Spatial(candidates = candidates,\n", " voter_dist = sample_uniform_disc, voter_params = voter_params,\n", " candidate_dist = sample_uniform_disc, candidate_params = candidate_params,\n", " distance = distance)" @@ -491,7 +490,7 @@ "outputs": [], "source": [ "# Generate a profile from random candidate and voter positions\n", - "profile, candidate_position_dict, voter_positions = generator.generate_profile(number_of_ballots = n, seed = None)" + "profile, candidate_position_dict, voter_positions = generator.generate_profile(number_of_ballots = n)" ] }, { @@ -659,7 +658,7 @@ "candidate_params = {'low': 0, 'high': 1, 'size': 2}\n", "distance = lambda point1, point2: np.linalg.norm(point1 - point2)\n", "\n", - "generator = DSpatial(candidates = candidates,\n", + "generator = Spatial(candidates = candidates,\n", " voter_dist = np.random.uniform, voter_params = voter_params,\n", " candidate_dist = np.random.uniform, candidate_params = candidate_params,\n", " distance = distance)" @@ -673,7 +672,7 @@ "outputs": [], "source": [ "# Generate a profile from random candidate and voter positions\n", - "profile, candidate_position_dict, voter_positions = generator.generate_profile(number_of_ballots = n, seed = None)" + "profile, candidate_position_dict, voter_positions = generator.generate_profile(number_of_ballots = n)" ] }, { @@ -872,7 +871,7 @@ "\n", "distance = lambda point1, point2: np.linalg.norm(point1 - point2)\n", "\n", - "generator = DSpatial(candidates = candidates,\n", + "generator = Spatial(candidates = candidates,\n", " voter_dist = sample_from_mixture, voter_params = voter_params,\n", " candidate_dist = np.random.uniform, candidate_params = candidate_params,\n", " distance = distance)" @@ -886,7 +885,7 @@ "outputs": [], "source": [ "# Generate a profile from random candidate and voter positions\n", - "profile, candidate_position_dict, voter_positions = generator.generate_profile(number_of_ballots = n, seed = None)" + "profile, candidate_position_dict, voter_positions = generator.generate_profile(number_of_ballots = n)" ] }, { diff --git a/src/votekit/ballot_generator.py b/src/votekit/ballot_generator.py index cf2a43e..165058b 100644 --- a/src/votekit/ballot_generator.py +++ b/src/votekit/ballot_generator.py @@ -1951,7 +1951,7 @@ def generate_profile( return pp -class DSpatial(BallotGenerator): +class Spatial(BallotGenerator): """ Spatial model for ballot generation. In some metric space determined by an input distance function, randomly sample each voter's and @@ -2003,28 +2003,61 @@ def __init__( self.candidate_dist = candidate_dist if voter_params is None: - # default params used for np.random.uniform - self.voter_params = {"low": 0.0, "high": 1.0, "size": 2.0} + if voter_dist is np.random.uniform: + self.voter_params = {"low": 0.0, "high": 1.0, "size": 2.0} + else: + raise ValueError( + "No parameters were given for the input voter distribution." + ) else: + try: + self.voter_dist(**voter_params) + except TypeError: + raise TypeError("Invalid parameters for the voter distribution.") + self.voter_params = voter_params if candidate_params is None: - # default params used for np.random.uniform - self.candidate_params = {"low": 0.0, "high": 1.0, "size": 2.0} + if candidate_dist is np.random.uniform: + self.candidate_params = {"low": 0.0, "high": 1.0, "size": 2.0} + else: + raise ValueError( + "No parameters were given for the input candidate distribution." + ) else: + try: + self.candidate_dist(**candidate_params) + except TypeError: + raise TypeError("Invalid parameters for the candidate distribution.") + self.candidate_params = candidate_params + try: + v = self.voter_dist(**self.voter_params) + c = self.candidate_dist(**self.candidate_params) + distance(v, c) + except TypeError: + raise ValueError( + "Distance function is invalid or incompatible " + "with voter/candidate distributions." + ) + self.distance = distance def generate_profile( - self, number_of_ballots: int, by_bloc: bool = False, seed: Optional[int] = None + self, number_of_ballots: int, by_bloc: bool = False ) -> Union[PreferenceProfile, Tuple]: """ + Samples a metric position for number_of_ballots voters from + the voter distribution. Samples a metric position for each candidate + from the input candidate distribution. With sampled + positions, this method then creates a ranked PreferenceProfile in which + voter's preferences are consistent with their distances to the candidates + in the metric space. + Args: number_of_ballots (int): The number of ballots to generate. by_bloc (bool): Dummy variable from parent class. - seed (int, optional): Seed for random generation, defaults to None - which resets the random seed. Returns: (Union[PreferenceProfile, Tuple]): @@ -2037,7 +2070,6 @@ def generate_profile( in the metric space. """ - np.random.seed(seed) candidate_position_dict = { c: self.candidate_dist(**self.candidate_params) for c in self.candidates } @@ -2045,16 +2077,14 @@ def generate_profile( [self.voter_dist(**self.voter_params) for v in range(number_of_ballots)] ) - ballot_pool = [] - for v in voter_positions: + ballot_pool = [["c"] * len(self.candidates) for _ in range(number_of_ballots)] + for v in range(number_of_ballots): distance_dict = { - i: self.distance(v, c) for i, c, in candidate_position_dict.items() + c: self.distance(voter_positions[v], c_position) + for c, c_position in candidate_position_dict.items() } candidate_order = sorted(distance_dict, key=distance_dict.__getitem__) - ballot_pool.append(candidate_order) - - # reset the seed - np.random.seed(None) + ballot_pool[v] = candidate_order return ( self.ballot_pool_to_profile(ballot_pool, self.candidates), @@ -2063,15 +2093,20 @@ def generate_profile( ) -class Clustered_DSpatial(BallotGenerator): +class ClusteredSpatial(BallotGenerator): """ Clustered spatial model for ballot generation. In some metric space determined by an input distance function, randomly sample each candidate's positions from input candidate distribution. Then sample voters's positions from a distribution centered around each - of the candidate's positions. Using generate_profile() - outputs a ranked profile which is consistent - with the sampled positions (respects distances). + of the candidate's positions. + + NOTE: We currently only support the following list of voter distributions: + [np.random.normal, np.random.laplace, np.random.logistic, np.random.gumbel], + which is the complete list of numpy distributions that accept a 'loc' parameter allowing + us to center the distribution around each candidate. For more + information on numpy supported distributions and their parameters, please visit: + https://numpy.org/doc/1.16/reference/routines.random.html. Args: candidates (list[str]): List of candidate strings. @@ -2082,7 +2117,7 @@ class Clustered_DSpatial(BallotGenerator): candidate_dist: (Callable[..., np.ndarray], optional): Distribution to sample a single candidate's position from, defaults to uniform distribution. candidate_params: (Optional[Dict[str, float]], optional): Parameters to be passed - to candidate_dist, defaults None which creates the unif(0,1) + to candidate_dist, defaults None which creates the unif(0,1) distribution in 2 dimensions. distance: (Callable[[np.ndarray, np.ndarray], float]], optional): Computes distance between a voter and a candidate, @@ -2096,7 +2131,7 @@ class Clustered_DSpatial(BallotGenerator): candidate_dist: (Callable[..., np.ndarray], optional): Distribution to sample a single candidate's position from, defaults to uniform distribution. candidate_params: (Optional[Dict[str, float]], optional): Parameters to be passed - to candidate_dist, defaults None which creates the unif(0,1) + to candidate_dist, defaults None which creates the unif(0,1) distribution in 2 dimensions. distance: (Callable[[np.ndarray, np.ndarray], float]], optional): Computes distance between a voter and a candidate, @@ -2117,38 +2152,71 @@ def __init__( self.voter_dist = voter_dist if voter_params is None: - # default params used for np.random.normal - self.voter_params = {"loc": 0, "std": np.array(1.0), "size": np.array(2.0)} + if self.voter_dist is np.random.normal: + self.voter_params = { + "loc": 0, + "std": np.array(1.0), + "size": np.array(2.0), + } + else: + raise ValueError( + "No parameters were given for the input voter distribution." + ) else: - # Trying to ensure that the input distribution's mean is parameterized. - # This allows me to center it on the candidates themselves later + if voter_dist.__name__ not in ["normal", "laplace", "logistic", "gumbel"]: + raise ValueError("Input voter distribution not supported.") + try: - voter_params['loc'] = 0 + voter_params["loc"] = 0 self.voter_dist(**voter_params) except TypeError: - raise ValueError("Invalid parameters for the voter distribution, make sure\ - that the input distribution has a 'loc' parameter specifying the mean.") - + raise TypeError("Invalid parameters for the voter distribution.") + self.voter_params = voter_params if candidate_params is None: - # default params used for np.random.uniform - self.candidate_params = {"low": 0.0, "high": 1.0, "size": 2.0} + if self.candidate_dist is np.random.uniform: + self.candidate_params = {"low": 0.0, "high": 1.0, "size": 2.0} + else: + raise ValueError( + "No parameters were given for the input candidate distribution." + ) else: + try: + self.candidate_dist(**candidate_params) + except TypeError: + raise TypeError("Invalid parameters for the candidate distribution.") + self.candidate_params = candidate_params + try: + v = self.voter_dist(**self.voter_params) + c = self.candidate_dist(**self.candidate_params) + distance(v, c) + except TypeError: + raise ValueError( + "Distance function is invalid or incompatible " + "with voter/candidate distributions." + ) + self.distance = distance def generate_profile_with_dict( - self, number_of_ballots: dict[str,int], by_bloc: bool = False, seed: Optional[int] = None + self, number_of_ballots: dict[str, int], by_bloc: bool = False ) -> Union[PreferenceProfile, Tuple]: """ + Samples a metric position for each candidate + from the input candidate distribution. For each candidate, then sample + number_of_ballots[candidate] metric positions for voters + which will be centered around the candidate. + With sampled positions, this method then creates a ranked PreferenceProfile in which + voter's preferences are consistent with their distances to the candidates + in the metric space. + Args: number_of_ballots (dict[str, int]): The number of voters attributed - to each candidate {candidate string: # voters} + to each candidate {candidate string: # voters}. by_bloc (bool): Dummy variable from parent class. - seed (int, optional): Seed for random generation, defaults to None - which resets the random seed. Returns: (Union[PreferenceProfile, Tuple]): @@ -2161,29 +2229,32 @@ def generate_profile_with_dict( in the metric space. """ - np.random.seed(seed) candidate_position_dict = { c: self.candidate_dist(**self.candidate_params) for c in self.candidates } - voter_positions = [] - for c in self.candidates: - for v in range(number_of_ballots[c]): - self.voter_params['loc'] = candidate_position_dict[c] - voter_positions.append(self.voter_dist(**self.voter_params)) - voter_positions_array = np.vstack(voter_positions) + n_voters = sum(number_of_ballots.values()) + voter_positions = [np.zeros(2) for _ in range(n_voters)] + vidx = 0 + for c, c_position in candidate_position_dict.items(): + for v in range(number_of_ballots[c]): + self.voter_params["loc"] = c_position + voter_positions[vidx] = self.voter_dist(**self.voter_params) + vidx += 1 - ballot_pool = [] - for v_position in voter_positions: + ballot_pool = [ + ["c"] * len(self.candidates) for _ in range(len(voter_positions)) + ] + for v in range(len(voter_positions)): + v_position = voter_positions[v] distance_dict = { c: self.distance(v_position, c_position) for c, c_position, in candidate_position_dict.items() } candidate_order = sorted(distance_dict, key=distance_dict.__getitem__) - ballot_pool.append(candidate_order) + ballot_pool[v] = candidate_order - # reset the seed - np.random.seed(None) + voter_positions_array = np.vstack(voter_positions) return ( self.ballot_pool_to_profile(ballot_pool, self.candidates), diff --git a/src/votekit/elections/election_types.py b/src/votekit/elections/election_types.py index 9f94652..a744e42 100644 --- a/src/votekit/elections/election_types.py +++ b/src/votekit/elections/election_types.py @@ -1130,17 +1130,20 @@ class RandomDictator(Election): Args: profile (PreferenceProfile): PreferenceProfile to run election on. - seats (int): Number of seats to elect. + m (int): Number of seats to elect. Attributes: _profile (PreferenceProfile): PreferenceProfile to run election on. - seats (int): Number of seats to be elected. + m (int): Number of seats to be elected. """ - def __init__(self, profile: PreferenceProfile, seats: int): + def __init__(self, profile: PreferenceProfile, m: int): super().__init__(profile, ballot_ties=False) - self.seats = seats + if m <= 0 or m > len(profile.get_candidates()): + raise ValueError("Invalid number of candidates to elect") + + self.m = m def next_round(self) -> bool: """ @@ -1150,9 +1153,18 @@ def next_round(self) -> bool: (bool) True if number of seats has not been met, False otherwise. """ cands_elected = [len(s) for s in self.state.winners()] - return sum(cands_elected) < self.seats + return sum(cands_elected) < self.m def run_step(self): + """ + If m candidates have not yet been elected: + finds a single winning candidate to add to the list of elected + candidates by sampling from the distribution of first place votes. + Removes that candidate from all ballots in the preference profile. + + Returns: + ElectionState: An ElectionState object for a complete election. + """ if self.next_round(): remaining = self.state.profile.get_candidates() @@ -1162,21 +1174,12 @@ def run_step(self): self.state.profile.ballots, weights=weights, k=1 )[0] - # randomly choose a winner from the first place rankings winning_candidate = random.choice(list(random_ballot.ranking[0])) - - # some formatting to make it compatible with ElectionState, which - # requires a list of sets of strings elected = [{winning_candidate}] - - # remove the winner from the ballots new_ballots = remove_cand(winning_candidate, self.state.profile.ballots) new_profile = PreferenceProfile(ballots=new_ballots) - - # determine who remains remaining = [{c} for c in remaining if c != winning_candidate] - # update for the next round self.state = ElectionState( curr_round=self.state.curr_round + 1, elected=elected, @@ -1185,17 +1188,6 @@ def run_step(self): profile=new_profile, previous=self.state, ) - - # if this is the last round, move remaining to eliminated - if not self.next_round(): - self.state = ElectionState( - curr_round=self.state.curr_round, - elected=elected, - eliminated_cands=remaining, - remaining=[], - profile=new_profile, - previous=self.state.previous, - ) return self.state def run_election(self): @@ -1209,9 +1201,9 @@ def run_election(self): class BoostedRandomDictator(Election): """ Modified random dictator where - - With probability (1 - 1/(# Candidates - 1)) + - With probability (1 - 1/(n_candidates - 1)) choose a winner randomly from the distribution of first place votes. - - With probability 1/(# of Candidates - 1) + - With probability 1/(n_candidates - 1) Choose a winner via a proportional to squares rule. For multi-winner elections @@ -1220,17 +1212,20 @@ class BoostedRandomDictator(Election): Args: profile (PreferenceProfile): PreferenceProfile to run election on. - seats (int): Number of seats to elect. + m (int): Number of seats to elect. Attributes: _profile (PreferenceProfile): PreferenceProfile to run election on. - seats (int): Number of seats to be elected. + m (int): Number of seats to be elected. """ - def __init__(self, profile: PreferenceProfile, seats: int): + def __init__(self, profile: PreferenceProfile, m: int): super().__init__(profile, ballot_ties=False) - self.seats = seats + if m <= 0 or m > len(profile.get_candidates()): + raise ValueError("Invalid number of candidates to elect") + + self.m = m def next_round(self) -> bool: """ @@ -1240,9 +1235,19 @@ def next_round(self) -> bool: (bool) True if number of seats has not been met, False otherwise. """ cands_elected = [len(s) for s in self.state.winners()] - return sum(cands_elected) < self.seats + return sum(cands_elected) < self.m def run_step(self): + """ + If m candidates have not yet been elected: + finds a single winning candidate to add to the list of elected + candidates by sampling from the distribution induced by the combination + of random dictator and proportional to squares election rules. + Removes that candidate from all ballots in the preference profile. + + Returns: + ElectionState: An ElectionState object for a complete election. + """ if self.next_round(): remaining = self.state.profile.get_candidates() u = random.uniform(0, 1) @@ -1251,18 +1256,12 @@ def run_step(self): winning_candidate = remaining[0] elif u <= 1 / (len(remaining) - 1): - # Choose via proportional to squares - candidate_votes = {c: 0 for c in remaining} - for ballot in self.state.profile.get_ballots(): - top_choice = random.choice(list(ballot.ranking[0])) - candidate_votes[top_choice] += float(ballot.weight) - - squares = np.array( - [(i / len(remaining)) ** 2 for i in candidate_votes.values()] - ) - sum_of_squares = np.sum(squares) - probabilities = squares / sum_of_squares - winning_candidate = np.random.choice(remaining, p=probabilities) + candidate_votes = first_place_votes(self.state.profile, to_float=True) + p = np.array([i for i in candidate_votes.values()]) + p /= float(self.state.profile.num_ballots()) + p = np.power(p, 2) + p /= np.sum(p) + winning_candidate = np.random.choice(remaining, p=p) else: ballots = self.state.profile.ballots @@ -1270,21 +1269,13 @@ def run_step(self): random_ballot = random.choices( self.state.profile.ballots, weights=weights, k=1 )[0] - # randomly choose a winner according to first place rankings winning_candidate = random.choice(list(random_ballot.ranking[0])) - # some formatting to make it compatible with ElectionState, which - # requires a list of sets of strings elected = [{winning_candidate}] - - # remove the winner from the ballots new_ballots = remove_cand(winning_candidate, self.state.profile.ballots) new_profile = PreferenceProfile(ballots=new_ballots) - - # determine who remains remaining = [{c} for c in remaining if c != winning_candidate] - # update for the next round self.state = ElectionState( curr_round=self.state.curr_round + 1, elected=elected, @@ -1293,21 +1284,9 @@ def run_step(self): profile=new_profile, previous=self.state, ) - - # if this is the last round, move remaining to eliminated - if not self.next_round(): - self.state = ElectionState( - curr_round=self.state.curr_round, - elected=elected, - eliminated_cands=remaining, - remaining=[], - profile=new_profile, - previous=self.state.previous, - ) return self.state def run_election(self): - # run steps until we elect the required number of candidates while self.next_round(): self.run_step() @@ -1323,17 +1302,37 @@ class PluralityVeto(Election): Args: profile (PreferenceProfile): PreferenceProfile to run election on. - seats (int): Number of seats to elect. + m (int): Number of seats to elect. Attributes: _profile (PreferenceProfile): PreferenceProfile to run election on. - seats (int): Number of seats to be elected. + m (int): Number of seats to be elected. + ballot_idx (dict[int, int]): indexes individual voters to condensed profile ballots + random_order (list[int]): randomly shuffled order of voter indices + candidate_approvals (dict[str,int]): dictionary tracking current candidate scores + """ - def __init__(self, profile: PreferenceProfile, seats: int): + def __init__(self, profile: PreferenceProfile, m: int): super().__init__(profile, ballot_ties=False) - self.seats = seats + if m <= 0 or m > len(profile.get_candidates()): + raise ValueError("Invalid number of candidates to elect.") + + self.m = m + + bidx = 0 + self.ballot_idx = {i: -1 for i in range(int(self.state.profile.num_ballots()))} + for i, ballot in enumerate(self.state.profile.get_ballots()): + if not int(ballot.weight) == ballot.weight: + raise ValueError("Ballots must have integer weight.") + + for j in range(int(ballot.weight)): + self.ballot_idx[i] = bidx + bidx += 1 + + self.random_order = None + self.candidate_approvals = None def next_round(self) -> bool: """ @@ -1343,93 +1342,87 @@ def next_round(self) -> bool: (bool) True if number of seats has not been met, False otherwise. """ cands_elected = [len(s) for s in self.state.winners()] - return sum(cands_elected) < self.seats + return sum(cands_elected) < self.m def run_step(self): + """ + If m candidates have not yet been elected: + if the current round is 0, count plurality scores and remove all + candidates with a score of 0 to eliminated. Otherwise, this method + eliminates a single candidate by decrementing scores of candidates on + the current ticket until someone falls to a score of 0. Once we find + that there are exactly m candidates remaining on the ticket, elect all + of them. + + Returns: + ElectionState: An ElectionState object for a complete election. + """ if self.next_round(): candidates = self.state.profile.get_candidates() ballots = self.state.profile.ballots - # First, count a plurality score for each of the candidates - candidate_approvals = {c: Fraction(0) for c in candidates} - for ballot in ballots: - # From each ballot, randomly choose one candidate from the - # set of their first place ranking candidates to accept - first_choice = random.choice(list(ballot.ranking[0])) - candidate_approvals[first_choice] += ballot.weight - - # Next take a randomized ordering of the ballots: - random_order = np.random.permutation(len(ballots)) - - # Use another dictionary to keep track of which candidates have - # non-zero approval scores - A = {c: score for c, score in candidate_approvals.items() if score > 0} - - # Finally, decrement scores with vetos from each of the voters - last_eliminated = None - for r in random_order: - # From each ballot, look at all the remaining candidates - # in A, and veto one which this ballot ranks lowest. - # This might be expensive, let me know if you have any ideas for how to improve - ballot = ballots[r] - - max_rank = -1 - max_rank_cands = [] - for c in A.keys(): - for i, cand_set in enumerate(ballot.ranking): - if c in cand_set: - if i > max_rank: - max_rank = i - max_rank_cands = [c] - elif i == max_rank: - max_rank_cands.append(c) - - last_choice = random.choice(max_rank_cands) - A[last_choice] -= ballot.weight - - # if score falls below 0, eliminate that candidate - if A[last_choice] <= 0: - del A[last_choice] - last_eliminated = last_choice - - # The very last eliminated candidate is the winner - winning_candidate = last_eliminated - - # some formatting to make it compatible with ElectionState, which - # requires a list of sets of strings - elected = [{winning_candidate}] - - # remove the winner from the ballots - new_ballots = remove_cand(winning_candidate, self.state.profile.ballots) - new_profile = PreferenceProfile(ballots=new_ballots) + if len(candidates) == self.m: + # move all to elected, this is the last round + elected = [{c} for c in candidates] + self.state = ElectionState( + curr_round=self.state.curr_round + 1, + elected=elected, + eliminated_cands=[], + remaining=[], + profile=self.state.profile, + previous=self.state, + ) - # determine who remains - remaining = [{c} for c in candidates if c != winning_candidate] + else: + if self.state.curr_round == 0: + eliminated = [ + c for c, score in self.candidate_approvals.items() if score <= 0 + ] - # update for the next round - self.state = ElectionState( - curr_round=self.state.curr_round + 1, - elected=elected, - eliminated_cands=[], - remaining=remaining, - profile=new_profile, - previous=self.state, - ) + else: + eliminated = ["c"] + last_idx = 0 + for i in range(len(self.random_order)): + last_idx = i + r = self.random_order[i] + ballot = ballots[self.ballot_idx[r]] + # Need to make a random choice between last place candidates, + # because voters should only get one veto + # if len(ballot.ranking) > 0: + least_preferred = random.choice(list(ballot.ranking[-1])) + self.candidate_approvals[least_preferred] -= 1 + if self.candidate_approvals[least_preferred] <= 0: + eliminated[0] = least_preferred + # Only want to eliminate one candidate per round so we break here + break + + # Update the randomized order so that + # we can continue where we left off next round + self.random_order = ( + self.random_order[last_idx + 1 :] + + self.random_order[: last_idx + 1] + ) - # if this is the last round, move remaining to eliminated - if not self.next_round(): + new_ballots = remove_cand(eliminated, self.state.profile.ballots) + new_profile = PreferenceProfile(ballots=new_ballots) + eliminated = [{c} for c in eliminated] + remaining = [{c} for c in new_profile.get_candidates()] self.state = ElectionState( - curr_round=self.state.curr_round, - elected=elected, - eliminated_cands=remaining, - remaining=[], + curr_round=self.state.curr_round + 1, + elected=[], + eliminated_cands=eliminated, + remaining=remaining, profile=new_profile, - previous=self.state.previous, + previous=self.state, ) + return self.state def run_election(self): - # run steps until we elect the required number of candidates + self.random_order = list(range(int(self.state.profile.num_ballots()))) + np.random.shuffle(self.random_order) + self.candidate_approvals = first_place_votes(self.state.profile, to_float=True) + while self.next_round(): self.run_step() diff --git a/src/votekit/metrics/distances.py b/src/votekit/metrics/distances.py index 367a0a0..9aeae6c 100644 --- a/src/votekit/metrics/distances.py +++ b/src/votekit/metrics/distances.py @@ -148,4 +148,4 @@ def em_array(pp: PreferenceProfile) -> list: def euclidean_dist(point1: np.ndarray, point2: np.ndarray) -> float: - return float(np.linalg.norm(point1 - point2)) + return float(np.linalg.norm(point1 - point2, ord=2)) diff --git a/tests/test_bg_errors.py b/tests/test_bg_errors.py index 6dbd0ac..96e4196 100644 --- a/tests/test_bg_errors.py +++ b/tests/test_bg_errors.py @@ -1,6 +1,12 @@ import pytest +import numpy as np -from votekit.ballot_generator import name_PlackettLuce, CambridgeSampler +from votekit.ballot_generator import ( + name_PlackettLuce, + CambridgeSampler, + Spatial, + ClusteredSpatial, +) from votekit.pref_interval import PreferenceInterval @@ -103,3 +109,150 @@ def test_Cambridge_maj_bloc_error(): W_bloc="A", C_bloc="A", ) + + +def test_spatial_generator(): + candidates = [str(i) for i in range(25)] + uniform_params = {"low": 0, "high": 1, "size": 2} + normal_params = {"loc": 0.5, "scale": 0.1, "size": 2} + + def bad_dist(x, y, z): + return x + y + z + + with pytest.raises( + ValueError, + match="No parameters were given for " "the input voter distribution.", + ): + Spatial( + candidates=candidates, + voter_dist=np.random.normal, + voter_params=None, + candidate_dist=np.random.normal, + candidate_params=normal_params, + ) + + with pytest.raises( + ValueError, + match="No parameters were given for " "the input candidate distribution.", + ): + Spatial( + candidates=candidates, + voter_dist=np.random.normal, + voter_params=normal_params, + candidate_dist=np.random.normal, + candidate_params=None, + ) + + with pytest.raises( + TypeError, match="Invalid parameters for the voter distribution." + ): + Spatial( + candidates=candidates, + voter_dist=np.random.normal, + voter_params=uniform_params, + candidate_dist=np.random.normal, + candidate_params=normal_params, + ) + + with pytest.raises( + TypeError, match="Invalid parameters for the candidate distribution." + ): + Spatial( + candidates=candidates, + voter_dist=np.random.normal, + voter_params=normal_params, + candidate_dist=np.random.normal, + candidate_params=uniform_params, + ) + + with pytest.raises( + ValueError, + match="Distance function is invalid or " + "incompatible with voter/candidate distributions.", + ): + Spatial( + candidates=candidates, + voter_dist=np.random.normal, + voter_params=normal_params, + candidate_dist=np.random.normal, + candidate_params=normal_params, + distance=bad_dist, + ) + + +def test_clustered_spatial_generator(): + candidates = [str(i) for i in range(25)] + uniform_params = {"low": 0, "high": 1, "size": 2} + normal_params = {"loc": 0.5, "scale": 0.1, "size": 2} + + def bad_dist(x, y, z): + return x + y + z + + with pytest.raises( + ValueError, + match="No parameters were given for " "the input voter distribution.", + ): + ClusteredSpatial( + candidates=candidates, + voter_dist=np.random.logistic, + voter_params=None, + candidate_dist=np.random.normal, + candidate_params=normal_params, + ) + + with pytest.raises( + ValueError, + match="No parameters were given for " "the input candidate distribution.", + ): + ClusteredSpatial( + candidates=candidates, + voter_dist=np.random.normal, + voter_params=normal_params, + candidate_dist=np.random.normal, + candidate_params=None, + ) + + with pytest.raises( + TypeError, match="Invalid parameters for the voter distribution." + ): + ClusteredSpatial( + candidates=candidates, + voter_dist=np.random.normal, + voter_params=uniform_params, + candidate_dist=np.random.normal, + candidate_params=normal_params, + ) + + with pytest.raises( + TypeError, match="Invalid parameters for the candidate distribution." + ): + ClusteredSpatial( + candidates=candidates, + voter_dist=np.random.normal, + voter_params=normal_params, + candidate_dist=np.random.normal, + candidate_params=uniform_params, + ) + + with pytest.raises( + ValueError, + match="Distance function is invalid or " + "incompatible with voter/candidate distributions.", + ): + ClusteredSpatial( + candidates=candidates, + voter_dist=np.random.normal, + voter_params=normal_params, + candidate_dist=np.random.normal, + candidate_params=normal_params, + distance=bad_dist, + ) + + with pytest.raises(ValueError, match="Input voter distribution not supported."): + ClusteredSpatial( + candidates=candidates, + voter_dist=np.random.uniform, + voter_params=normal_params, + candidate_dist=np.random.normal, + candidate_params=normal_params, + ) From 7727c9b32c0af5dd28b5730b43e3131a79edf3b3 Mon Sep 17 00:00:00 2001 From: Kevin Quinn Date: Thu, 8 Aug 2024 21:24:14 -0400 Subject: [PATCH 06/16] decondensing ballots --- src/votekit/elections/election_types.py | 34 ++++++++++++++++++------- 1 file changed, 25 insertions(+), 9 deletions(-) diff --git a/src/votekit/elections/election_types.py b/src/votekit/elections/election_types.py index a744e42..be347c4 100644 --- a/src/votekit/elections/election_types.py +++ b/src/votekit/elections/election_types.py @@ -9,6 +9,7 @@ from ..election_state import ElectionState from ..graphs.pairwise_comparison_graph import PairwiseComparisonGraph from ..pref_profile import PreferenceProfile +from ..ballot import Ballot from .transfers import fractional_transfer from ..utils import ( compute_votes, @@ -1301,13 +1302,13 @@ class PluralityVeto(Election): then chosen as the winner. Args: - profile (PreferenceProfile): PreferenceProfile to run election on. + profile (PreferenceProfile): PreferenceProfile to run election on. Note that + ballots muts have integer weights to be considered valid for this mechanism. m (int): Number of seats to elect. Attributes: _profile (PreferenceProfile): PreferenceProfile to run election on. m (int): Number of seats to be elected. - ballot_idx (dict[int, int]): indexes individual voters to condensed profile ballots random_order (list[int]): randomly shuffled order of voter indices candidate_approvals (dict[str,int]): dictionary tracking current candidate scores @@ -1321,16 +1322,31 @@ def __init__(self, profile: PreferenceProfile, m: int): self.m = m + # Decondense ballots + ballots = self.state.profile.get_ballots() + new_ballots = [Ballot() for i in range(int(self.state.profile.num_ballots()))] bidx = 0 - self.ballot_idx = {i: -1 for i in range(int(self.state.profile.num_ballots()))} - for i, ballot in enumerate(self.state.profile.get_ballots()): - if not int(ballot.weight) == ballot.weight: + for i, b in enumerate(ballots): + if not int(b.weight) == b.weight: raise ValueError("Ballots must have integer weight.") - for j in range(int(ballot.weight)): - self.ballot_idx[i] = bidx + for j in range(int(b.weight)): + new_ballots[bidx] = Ballot(b.ranking, weight=Fraction(1, 1)) bidx += 1 + new_profile = PreferenceProfile( + ballots=new_ballots, candidates=self.state.profile.get_candidates() + ) + + self.state = ElectionState( + curr_round=self.state.curr_round, + elected=[], + eliminated_cands=[], + remaining=self.state.remaining, + profile=new_profile, + previous=self.state.previous, + ) + self.random_order = None self.candidate_approvals = None @@ -1359,7 +1375,7 @@ def run_step(self): """ if self.next_round(): candidates = self.state.profile.get_candidates() - ballots = self.state.profile.ballots + ballots = self.state.profile.get_ballots() if len(candidates) == self.m: # move all to elected, this is the last round @@ -1385,7 +1401,7 @@ def run_step(self): for i in range(len(self.random_order)): last_idx = i r = self.random_order[i] - ballot = ballots[self.ballot_idx[r]] + ballot = ballots[r] # Need to make a random choice between last place candidates, # because voters should only get one veto # if len(ballot.ranking) > 0: From 5e4642cc94a61c53cf85fbab0c686f308fea8549 Mon Sep 17 00:00:00 2001 From: Chris Donnay Date: Fri, 9 Aug 2024 10:09:19 -0400 Subject: [PATCH 07/16] rename conflicted files --- src/votekit/elections/{__init__.py => kev__init__.py} | 0 .../elections/{election_types.py => kev_election_types.py} | 0 tests/{test_elections.py => kev_test_elections.py} | 0 3 files changed, 0 insertions(+), 0 deletions(-) rename src/votekit/elections/{__init__.py => kev__init__.py} (100%) rename src/votekit/elections/{election_types.py => kev_election_types.py} (100%) rename tests/{test_elections.py => kev_test_elections.py} (100%) diff --git a/src/votekit/elections/__init__.py b/src/votekit/elections/kev__init__.py similarity index 100% rename from src/votekit/elections/__init__.py rename to src/votekit/elections/kev__init__.py diff --git a/src/votekit/elections/election_types.py b/src/votekit/elections/kev_election_types.py similarity index 100% rename from src/votekit/elections/election_types.py rename to src/votekit/elections/kev_election_types.py diff --git a/tests/test_elections.py b/tests/kev_test_elections.py similarity index 100% rename from tests/test_elections.py rename to tests/kev_test_elections.py From bec6cea1ae7ebb7a0c91da8de2e66b7241184383 Mon Sep 17 00:00:00 2001 From: Chris Donnay Date: Fri, 9 Aug 2024 10:11:20 -0400 Subject: [PATCH 08/16] resolve file conflicts --- src/votekit/elections/__init__.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 src/votekit/elections/__init__.py diff --git a/src/votekit/elections/__init__.py b/src/votekit/elections/__init__.py new file mode 100644 index 0000000..bd30ccc --- /dev/null +++ b/src/votekit/elections/__init__.py @@ -0,0 +1,22 @@ +from .election_state import ElectionState # noqa +from ..models import Election # noqa +from .transfers import fractional_transfer, random_transfer # noqa +from .election_types import ( # noqa + RankingElection, + Plurality, + SNTV, + Borda, + STV, + IRV, + SequentialRCV, + Alaska, + DominatingSets, + CondoBorda, + TopTwo, + GeneralRating, + Rating, + Limited, + Cumulative, + Approval, + BlocPlurality, +) From be74c611862a675e83fc8dbbfd6a1c13e614f8ac Mon Sep 17 00:00:00 2001 From: Chris Donnay Date: Fri, 9 Aug 2024 14:07:12 -0400 Subject: [PATCH 09/16] refactor Kevin's code --- TODO.md | 3 + docs/api.rst | 12 + src/votekit/ballot_generator.py | 151 +- src/votekit/elections/__init__.py | 3 + .../elections/election_types/__init__.py | 3 + .../election_types/ranking/__init__.py | 3 + .../ranking/boosted_random_dictator.py | 116 ++ .../election_types/ranking/plurality_veto.py | 179 ++ .../election_types/ranking/random_dictator.py | 96 ++ src/votekit/elections/kev__init__.py | 21 - src/votekit/elections/kev_election_types.py | 1445 ----------------- tests/data/csv/test_pref_profile_to_csv.csv | 2 +- .../ranking/test_boosted_random_dictator.py | 32 + .../ranking/test_plurality_veto.py | 35 + .../ranking/test_random_dictator.py | 30 + tests/kev_test_elections.py | 285 ---- tests/test_bg_errors.py | 92 +- 17 files changed, 604 insertions(+), 1904 deletions(-) create mode 100644 TODO.md create mode 100644 src/votekit/elections/election_types/ranking/boosted_random_dictator.py create mode 100644 src/votekit/elections/election_types/ranking/plurality_veto.py create mode 100644 src/votekit/elections/election_types/ranking/random_dictator.py delete mode 100644 src/votekit/elections/kev__init__.py delete mode 100644 src/votekit/elections/kev_election_types.py create mode 100644 tests/elections/election_types/ranking/test_boosted_random_dictator.py create mode 100644 tests/elections/election_types/ranking/test_plurality_veto.py create mode 100644 tests/elections/election_types/ranking/test_random_dictator.py delete mode 100644 tests/kev_test_elections.py diff --git a/TODO.md b/TODO.md new file mode 100644 index 0000000..0e9cb01 --- /dev/null +++ b/TODO.md @@ -0,0 +1,3 @@ +- add some more tests to the dictator, boosted dictator, and plurality veto tests +- maybe more tests for spatial BGs, but we plan to edit that whole module anyway +- PV is not passing its test due to an issue with empty ballots being removed, thus messing up the random order \ No newline at end of file diff --git a/docs/api.rst b/docs/api.rst index fd6878e..1e7c562 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -66,6 +66,10 @@ Ranking-based :members: :show-inheritance: +.. automodule:: votekit.elections.election_types.ranking.boosted_random_dictator + :members: + :show-inheritance: + .. automodule:: votekit.elections.election_types.ranking.condo_borda :members: :show-inheritance: @@ -74,10 +78,18 @@ Ranking-based :members: :show-inheritance: +.. automodule:: votekit.elections.election_types.ranking.plurality_veto + :members: + :show-inheritance: + .. automodule:: votekit.elections.election_types.ranking.plurality :members: :show-inheritance: +.. automodule:: votekit.elections.election_types.ranking.random_dictator + :members: + :show-inheritance: + .. automodule:: votekit.elections.election_types.ranking.stv :members: :show-inheritance: diff --git a/src/votekit/ballot_generator.py b/src/votekit/ballot_generator.py index 19e1e18..abc6302 100644 --- a/src/votekit/ballot_generator.py +++ b/src/votekit/ballot_generator.py @@ -1965,11 +1965,11 @@ class Spatial(BallotGenerator): candidates (list[str]): List of candidate strings. voter_dist (Callable[..., np.ndarray], optional): Distribution to sample a single voter's position from, defaults to uniform distribution. - voter_params: (Optional[Dict[str, Any]], optional): Parameters to be passed to + voter_dist_kwargs: (Optional[Dict[str, Any]], optional): Keyword args to be passed to voter_dist, defaults to None, which creates the unif(0,1) distribution in 2 dimensions. candidate_dist: (Callable[..., np.ndarray], optional): Distribution to sample a single candidate's position from, defaults to uniform distribution. - candidate_params: (Optional[Dict[str, Any]], optional): Parameters to be passed + candidate_dist_kwargs: (Optional[Dict[str, Any]], optional): Keyword args to be passed to candidate_dist, defaults to None, which creates the unif(0,1) distribution in 2 dimensions. distance: (Callable[[np.ndarray, np.ndarray], float]], optional): @@ -1979,11 +1979,11 @@ class Spatial(BallotGenerator): candidates (list[str]): List of candidate strings. voter_dist (Callable[..., np.ndarray], optional): Distribution to sample a single voter's position from, defaults to uniform distribution. - voter_params: (Optional[Dict[str, Any]], optional): Parameters to be passed to + voter_dist_kwargs: (Optional[Dict[str, Any]], optional): Keyword args to be passed to voter_dist, defaults to None, which creates the unif(0,1) distribution in 2 dimensions. candidate_dist: (Callable[..., np.ndarray], optional): Distribution to sample a single candidate's position from, defaults to uniform distribution. - candidate_params: (Optional[Dict[str, Any]], optional): Parameters to be passed + candidate_dist_kwargs: (Optional[Dict[str, Any]], optional): Keyword args to be passed to candidate_dist, defaults to None, which creates the unif(0,1) distribution in 2 dimensions. distance: (Callable[[np.ndarray, np.ndarray], float]], optional): @@ -1995,51 +1995,47 @@ def __init__( self, candidates: list[str], voter_dist: Callable[..., np.ndarray] = np.random.uniform, - voter_params: Optional[Dict[str, Any]] = None, + voter_dist_kwargs: Optional[Dict[str, Any]] = None, candidate_dist: Callable[..., np.ndarray] = np.random.uniform, - candidate_params: Optional[Dict[str, Any]] = None, + candidate_dist_kwargs: Optional[Dict[str, Any]] = None, distance: Callable[[np.ndarray, np.ndarray], float] = euclidean_dist, ): super().__init__(candidates=candidates) self.voter_dist = voter_dist self.candidate_dist = candidate_dist - if voter_params is None: + if voter_dist_kwargs is None: if voter_dist is np.random.uniform: - self.voter_params = {"low": 0.0, "high": 1.0, "size": 2.0} + voter_dist_kwargs = {"low": 0.0, "high": 1.0, "size": 2.0} else: - raise ValueError( - "No parameters were given for the input voter distribution." - ) - else: - try: - self.voter_dist(**voter_params) - except TypeError: - raise TypeError("Invalid parameters for the voter distribution.") + voter_dist_kwargs = {} + + try: + self.voter_dist(**voter_dist_kwargs) + except TypeError: + raise TypeError("Invalid kwargs for the voter distribution.") - self.voter_params = voter_params + self.voter_dist_kwargs = voter_dist_kwargs - if candidate_params is None: + if candidate_dist_kwargs is None: if candidate_dist is np.random.uniform: - self.candidate_params = {"low": 0.0, "high": 1.0, "size": 2.0} + candidate_dist_kwargs = {"low": 0.0, "high": 1.0, "size": 2.0} else: - raise ValueError( - "No parameters were given for the input candidate distribution." - ) - else: - try: - self.candidate_dist(**candidate_params) - except TypeError: - raise TypeError("Invalid parameters for the candidate distribution.") + candidate_dist_kwargs = {} + + try: + self.candidate_dist(**candidate_dist_kwargs) + except TypeError: + raise TypeError("Invalid kwargs for the candidate distribution.") - self.candidate_params = candidate_params + self.candidate_dist_kwargs = candidate_dist_kwargs try: - v = self.voter_dist(**self.voter_params) - c = self.candidate_dist(**self.candidate_params) + v = self.voter_dist(**self.voter_dist_kwargs) + c = self.candidate_dist(**self.candidate_dist_kwargs) distance(v, c) except TypeError: - raise ValueError( + raise TypeError( "Distance function is invalid or incompatible " "with voter/candidate distributions." ) @@ -2048,7 +2044,7 @@ def __init__( def generate_profile( self, number_of_ballots: int, by_bloc: bool = False - ) -> Union[PreferenceProfile, Tuple]: + ) -> Tuple[PreferenceProfile, dict[str, np.ndarray], np.ndarray]: """ Samples a metric position for number_of_ballots voters from the voter distribution. Samples a metric position for each candidate @@ -2062,10 +2058,7 @@ def generate_profile( by_bloc (bool): Dummy variable from parent class. Returns: - (Union[PreferenceProfile, Tuple]): - preference profile (Preference Profile), - candidate positions (dict[str, np.ndarray), - voter positions (np.ndarray): + Tuple[PreferenceProfile, dict[str, numpy.ndarray], numpy.ndarray]: A tuple containing the preference profile object, a dictionary with each candidate's position in the metric space, and a matrix where each row is a single voter's position @@ -2073,10 +2066,14 @@ def generate_profile( """ candidate_position_dict = { - c: self.candidate_dist(**self.candidate_params) for c in self.candidates + c: self.candidate_dist(**self.candidate_dist_kwargs) + for c in self.candidates } voter_positions = np.array( - [self.voter_dist(**self.voter_params) for v in range(number_of_ballots)] + [ + self.voter_dist(**self.voter_dist_kwargs) + for v in range(number_of_ballots) + ] ) ballot_pool = [["c"] * len(self.candidates) for _ in range(number_of_ballots)] @@ -2114,11 +2111,11 @@ class ClusteredSpatial(BallotGenerator): candidates (list[str]): List of candidate strings. voter_dist (Callable[..., np.ndarray], optional): Distribution to sample a single voter's position from, defaults to normal(0,1) distribution. - voter_params: (Optional[dict[str, Any]], optional): Parameters to be passed to + voter_dist_kwargs: (Optional[dict[str, Any]], optional): Keyword args to be passed to voter_dist, defaults to None, which creates the unif(0,1) distribution in 2 dimensions. candidate_dist: (Callable[..., np.ndarray], optional): Distribution to sample a single candidate's position from, defaults to uniform distribution. - candidate_params: (Optional[Dict[str, float]], optional): Parameters to be passed + candidate_dist_kwargs: (Optional[Dict[str, float]], optional): Keyword args to be passed to candidate_dist, defaults None which creates the unif(0,1) distribution in 2 dimensions. distance: (Callable[[np.ndarray, np.ndarray], float]], optional): @@ -2128,11 +2125,11 @@ class ClusteredSpatial(BallotGenerator): candidates (list[str]): List of candidate strings. voter_dist (Callable[..., np.ndarray], optional): Distribution to sample a single voter's position from, defaults to uniform distribution. - voter_params: (Optional[dict[str, Any]], optional): Parameters to be passed to + voter_dist_kwargs: (Optional[dict[str, Any]], optional): Keyword args to be passed to voter_dist, defaults to None, which creates the unif(0,1) distribution in 2 dimensions. candidate_dist: (Callable[..., np.ndarray], optional): Distribution to sample a single candidate's position from, defaults to uniform distribution. - candidate_params: (Optional[Dict[str, float]], optional): Parameters to be passed + candidate_dist_kwargs: (Optional[Dict[str, float]], optional): Keyword args to be passed to candidate_dist, defaults None which creates the unif(0,1) distribution in 2 dimensions. distance: (Callable[[np.ndarray, np.ndarray], float]], optional): @@ -2144,59 +2141,55 @@ def __init__( self, candidates: list[str], voter_dist: Callable[..., np.ndarray] = np.random.normal, - voter_params: Optional[Dict[str, Any]] = None, + voter_dist_kwargs: Optional[Dict[str, Any]] = None, candidate_dist: Callable[..., np.ndarray] = np.random.uniform, - candidate_params: Optional[Dict[str, Any]] = None, + candidate_dist_kwargs: Optional[Dict[str, Any]] = None, distance: Callable[[np.ndarray, np.ndarray], float] = euclidean_dist, ): super().__init__(candidates=candidates) self.candidate_dist = candidate_dist self.voter_dist = voter_dist - if voter_params is None: + if voter_dist_kwargs is None: if self.voter_dist is np.random.normal: - self.voter_params = { + voter_dist_kwargs = { "loc": 0, "std": np.array(1.0), "size": np.array(2.0), } else: - raise ValueError( - "No parameters were given for the input voter distribution." - ) - else: - if voter_dist.__name__ not in ["normal", "laplace", "logistic", "gumbel"]: - raise ValueError("Input voter distribution not supported.") + voter_dist_kwargs = {} - try: - voter_params["loc"] = 0 - self.voter_dist(**voter_params) - except TypeError: - raise TypeError("Invalid parameters for the voter distribution.") + if voter_dist.__name__ not in ["normal", "laplace", "logistic", "gumbel"]: + raise ValueError("Input voter distribution not supported.") - self.voter_params = voter_params + try: + voter_dist_kwargs["loc"] = 0 + self.voter_dist(**voter_dist_kwargs) + except TypeError: + raise TypeError("Invalid kwargs for the voter distribution.") - if candidate_params is None: + self.voter_dist_kwargs = voter_dist_kwargs + + if candidate_dist_kwargs is None: if self.candidate_dist is np.random.uniform: - self.candidate_params = {"low": 0.0, "high": 1.0, "size": 2.0} + candidate_dist_kwargs = {"low": 0.0, "high": 1.0, "size": 2.0} else: - raise ValueError( - "No parameters were given for the input candidate distribution." - ) - else: - try: - self.candidate_dist(**candidate_params) - except TypeError: - raise TypeError("Invalid parameters for the candidate distribution.") + candidate_dist_kwargs = {} - self.candidate_params = candidate_params + try: + self.candidate_dist(**candidate_dist_kwargs) + except TypeError: + raise TypeError("Invalid kwargs for the candidate distribution.") + + self.candidate_dist_kwargs = candidate_dist_kwargs try: - v = self.voter_dist(**self.voter_params) - c = self.candidate_dist(**self.candidate_params) + v = self.voter_dist(**self.voter_dist_kwargs) + c = self.candidate_dist(**self.candidate_dist_kwargs) distance(v, c) except TypeError: - raise ValueError( + raise TypeError( "Distance function is invalid or incompatible " "with voter/candidate distributions." ) @@ -2205,7 +2198,7 @@ def __init__( def generate_profile_with_dict( self, number_of_ballots: dict[str, int], by_bloc: bool = False - ) -> Union[PreferenceProfile, Tuple]: + ) -> Tuple[PreferenceProfile, dict[str, np.ndarray], np.ndarray]: """ Samples a metric position for each candidate from the input candidate distribution. For each candidate, then sample @@ -2221,10 +2214,7 @@ def generate_profile_with_dict( by_bloc (bool): Dummy variable from parent class. Returns: - (Union[PreferenceProfile, Tuple]): - preference profile (Preference Profile), - candidate positions (dict[str, np.ndarray), - voter positions (np.ndarray): + Tuple[PreferenceProfile, dict[str, numpy.ndarray], numpy.ndarray]: A tuple containing the preference profile object, a dictionary with each candidate's position in the metric space, and a matrix where each row is a single voter's position @@ -2232,7 +2222,8 @@ def generate_profile_with_dict( """ candidate_position_dict = { - c: self.candidate_dist(**self.candidate_params) for c in self.candidates + c: self.candidate_dist(**self.candidate_dist_kwargs) + for c in self.candidates } n_voters = sum(number_of_ballots.values()) @@ -2240,8 +2231,8 @@ def generate_profile_with_dict( vidx = 0 for c, c_position in candidate_position_dict.items(): for v in range(number_of_ballots[c]): - self.voter_params["loc"] = c_position - voter_positions[vidx] = self.voter_dist(**self.voter_params) + self.voter_dist_kwargs["loc"] = c_position + voter_positions[vidx] = self.voter_dist(**self.voter_dist_kwargs) vidx += 1 ballot_pool = [ diff --git a/src/votekit/elections/__init__.py b/src/votekit/elections/__init__.py index bd30ccc..d35f1cb 100644 --- a/src/votekit/elections/__init__.py +++ b/src/votekit/elections/__init__.py @@ -19,4 +19,7 @@ Cumulative, Approval, BlocPlurality, + PluralityVeto, + RandomDictator, + BoostedRandomDictator, ) diff --git a/src/votekit/elections/election_types/__init__.py b/src/votekit/elections/election_types/__init__.py index 63b787e..a1ccf25 100644 --- a/src/votekit/elections/election_types/__init__.py +++ b/src/votekit/elections/election_types/__init__.py @@ -10,6 +10,9 @@ SequentialRCV, CondoBorda, TopTwo, + PluralityVeto, + RandomDictator, + BoostedRandomDictator, ) diff --git a/src/votekit/elections/election_types/ranking/__init__.py b/src/votekit/elections/election_types/ranking/__init__.py index bb35c83..d52dd66 100644 --- a/src/votekit/elections/election_types/ranking/__init__.py +++ b/src/votekit/elections/election_types/ranking/__init__.py @@ -12,3 +12,6 @@ from .dominating_sets import DominatingSets # noqa from .condo_borda import CondoBorda # noqa from .top_two import TopTwo # noqa +from .plurality_veto import PluralityVeto # noqa +from .random_dictator import RandomDictator # noqa +from .boosted_random_dictator import BoostedRandomDictator # noqa diff --git a/src/votekit/elections/election_types/ranking/boosted_random_dictator.py b/src/votekit/elections/election_types/ranking/boosted_random_dictator.py new file mode 100644 index 0000000..203f6f2 --- /dev/null +++ b/src/votekit/elections/election_types/ranking/boosted_random_dictator.py @@ -0,0 +1,116 @@ +from .abstract_ranking import RankingElection +from ....pref_profile import PreferenceProfile +from ...election_state import ElectionState +from ....utils import ( + first_place_votes, + remove_cand, + score_dict_to_ranking, + tiebreak_set, +) +import random +import numpy as np + + +class BoostedRandomDictator(RankingElection): + """ + Modified random dictator where with probability (1 - 1/(n_candidates - 1)) + choose a winner randomly from the distribution of first place votes. + With probability 1/(n_candidates - 1), choose a winner via a proportional to + squares rule. + + For multi-winner elections + repeat this process for every winner, removing that candidate from every + voter's ballot once they have been elected. + + Args: + profile (PreferenceProfile): PreferenceProfile to run election on. + m (int): Number of seats to elect. + + """ + + def __init__(self, profile: PreferenceProfile, m: int): + if m <= 0: + raise ValueError("m must be positive.") + elif m > len(profile.candidates): + raise ValueError( + "m must be less than or equal to the number of candidates." + ) + + self.m = m + super().__init__(profile, score_function=first_place_votes) + + def _is_finished(self) -> bool: + cands_elected = [len(s) for s in self.get_elected()] + return sum(cands_elected) >= self.m + + def _run_step( + self, profile: PreferenceProfile, prev_state: ElectionState, store_states=False + ) -> PreferenceProfile: + """ + Run one step of an election from the given profile and previous state. + If m candidates have not yet been elected: + finds a single winning candidate to add to the list of elected + candidates by sampling from the distribution induced by the combination + of random dictator and proportional to squares election rules. + Removes that candidate from all ballots in the preference profile. + + Args: + profile (PreferenceProfile): Profile of ballots. + prev_state (ElectionState): The previous ElectionState. + store_states (bool, optional): True if `self.election_states` should be updated with the + ElectionState generated by this round. This should only be True when used by + `self._run_election()`. Defaults to False. + + Returns: + PreferenceProfile: The profile of ballots after the round is completed. + """ + remaining_cands = profile.candidates + u = random.uniform(0, 1) + + if len(remaining_cands) == 1: + winning_candidate = remaining_cands[0] + + elif u <= 1 / (len(remaining_cands) - 1): + candidate_votes = prev_state.scores + p = np.array(list(candidate_votes.values())).astype("float64") + p /= float(profile.total_ballot_wt) + p = np.power(p, 2) + p /= np.sum(p) + winning_candidate = np.random.choice(list(candidate_votes.keys()), p=p) + tiebreaks = {} + + else: + ballots = profile.ballots + weights = [b.weight for b in ballots] + random_ballot = random.choices(profile.ballots, weights=weights, k=1)[0] + if random_ballot.ranking: + if len(random_ballot.ranking[0]) > 1: + tiebroken_ranking = tiebreak_set( + random_ballot.ranking[0], tiebreak="random" + ) + tiebreaks = {random_ballot.ranking[0]: tiebroken_ranking} + + else: + tiebroken_ranking = (random_ballot.ranking[0],) + tiebreaks = {} + + winning_candidate = list(tiebroken_ranking[0])[0] + + new_profile = remove_cand(winning_candidate, profile) + + if store_states: + elected = (frozenset({winning_candidate}),) + if self.score_function: + scores = self.score_function(new_profile) + remaining = score_dict_to_ranking(scores) + + new_state = ElectionState( + round_number=prev_state.round_number + 1, + elected=elected, + remaining=remaining, + scores=scores, + tiebreaks=tiebreaks, + ) + self.election_states.append(new_state) + + return new_profile diff --git a/src/votekit/elections/election_types/ranking/plurality_veto.py b/src/votekit/elections/election_types/ranking/plurality_veto.py new file mode 100644 index 0000000..930f392 --- /dev/null +++ b/src/votekit/elections/election_types/ranking/plurality_veto.py @@ -0,0 +1,179 @@ +from .abstract_ranking import RankingElection +from ....pref_profile import PreferenceProfile +from ....ballot import Ballot +from ...election_state import ElectionState +from ....utils import ( + first_place_votes, + remove_cand, + score_dict_to_ranking, + tiebreak_set, +) +from fractions import Fraction +import numpy as np +from typing import Optional + + +class PluralityVeto(RankingElection): + """ + Scores each candidate by their plurality (number of first) place votes, + then in a randomized order it lets each voter decrement the score of their + least favorite candidate. The candidate with the largest score at the end is + then chosen as the winner. + + Args: + profile (PreferenceProfile): PreferenceProfile to run election on. Note that + ballots must have integer weights to be considered valid for this mechanism. + m (int): Number of seats to elect. + tiebreak (str, optional): Tiebreak method to use. Options are None, 'random', and 'borda'. + Defaults to None, in which case a tie raises a ValueError. + + + """ + + def __init__( + self, profile: PreferenceProfile, m: int, tiebreak: Optional[str] = None + ): + self._pv_validate_profile(profile) + + if m <= 0: + raise ValueError("m must be positive.") + elif m > len(profile.candidates): + raise ValueError( + "m must be less than or equal to the number of candidates." + ) + + self.m = m + self.tiebreak = tiebreak + + # Decondense ballots + ballots = profile.ballots + new_ballots = [Ballot() for _ in range(int(profile.total_ballot_wt))] + bidx = 0 + for b in ballots: + for _ in range(int(b.weight)): + new_ballots[bidx] = Ballot(b.ranking, weight=Fraction(1, 1)) + bidx += 1 + + profile = PreferenceProfile( + ballots=tuple(new_ballots), candidates=profile.candidates + ) + + self.random_order = list(range(int(profile.num_ballots))) + np.random.shuffle(self.random_order) + + super().__init__(profile, score_function=first_place_votes) + + def _pv_validate_profile(self, profile: PreferenceProfile): + """ + Validate that each ballot has a ranking and that each + ballot has integer weight. + """ + for ballot in profile.ballots: + if not ballot.ranking or len(ballot.ranking) == 0: + raise TypeError("Ballots must have rankings.") + elif int(ballot.weight) != ballot.weight: + raise TypeError(f"Ballot {ballot} has non-integer weight.") + + def _is_finished(self) -> bool: + cands_elected = [len(s) for s in self.get_elected()] + return sum(cands_elected) >= self.m + + def _run_step( + self, profile: PreferenceProfile, prev_state: ElectionState, store_states=False + ) -> PreferenceProfile: + """ + Run one step of an election from the given profile and previous state. + If m candidates have not yet been elected: + if the current round is 0, count plurality scores and remove all + candidates with a score of 0 to eliminated. Otherwise, this method + eliminates a single candidate by decrementing scores of candidates on + the current ticket until someone falls to a score of 0. Once we find + that there are exactly m candidates remaining on the ticket, elect all + of them. + + Args: + profile (PreferenceProfile): Profile of ballots. + prev_state (ElectionState): The previous ElectionState. + store_states (bool, optional): True if `self.election_states` should be updated with the + ElectionState generated by this round. This should only be True when used by + `self._run_election()`. Defaults to False. + + Returns: + PreferenceProfile: The profile of ballots after the round is completed. + """ + + candidates = profile.candidates + ballots = profile.ballots + + if len(candidates) == self.m: + # move all to elected, this is the last round + elected = prev_state.remaining + new_profile = PreferenceProfile() + + if store_states: + if self.score_function: + scores = self.score_function(new_profile) + new_state = ElectionState( + round_number=prev_state.round_number + 1, + elected=elected, + scores=scores, + ) + + self.election_states.append(new_state) + + else: + tiebreaks = {} + new_scores = {c: s for c, s in prev_state.scores.items()} + + eliminated_cands = [] + if prev_state.round_number == 0: + eliminated_cands = [ + c for c, score in prev_state.scores.items() if score <= 0 + ] + + for i, ballot_index in enumerate(self.random_order): + # TODO problem, if ballot disappears after all candidates are removed, + # possible that an index will appear that is beyond the current list + # of ballots + ballot = ballots[ballot_index] + + if ballot.ranking: + # do with tiebreak methods + if len(ballot.ranking[-1]) > 1: + if self.tiebreak: + tiebroken_ranking = tiebreak_set( + ballot.ranking[-1], profile, self.tiebreak + ) + tiebreaks = {ballot.ranking[-1]: tiebroken_ranking} + else: + tiebroken_ranking = (ballot.ranking[-1],) + + least_preferred = list(tiebroken_ranking[-1])[0] + new_scores[least_preferred] -= Fraction(1) + + if new_scores[least_preferred] <= 0: + eliminated_cands.append(least_preferred) + break + + # Update the randomized order so that + # we can continue where we left off next round + self.random_order = self.random_order[i + 1 :] + + new_profile = remove_cand(eliminated_cands, profile) + + if store_states: + eliminated = (frozenset(eliminated_cands),) + if self.score_function: + scores = self.score_function(new_profile) + remaining = score_dict_to_ranking(scores) + new_state = ElectionState( + round_number=prev_state.round_number + 1, + eliminated=eliminated, + remaining=remaining, + scores=scores, + tiebreaks=tiebreaks, + ) + + self.election_states.append(new_state) + + return new_profile diff --git a/src/votekit/elections/election_types/ranking/random_dictator.py b/src/votekit/elections/election_types/ranking/random_dictator.py new file mode 100644 index 0000000..d4b8510 --- /dev/null +++ b/src/votekit/elections/election_types/ranking/random_dictator.py @@ -0,0 +1,96 @@ +from .abstract_ranking import RankingElection +from ....pref_profile import PreferenceProfile +from ...election_state import ElectionState +from ....utils import ( + first_place_votes, + remove_cand, + score_dict_to_ranking, + tiebreak_set, +) +import random + + +class RandomDictator(RankingElection): + """ + Choose a winner randomly from the distribution of first place votes. For multi-winner elections + repeat this process for every winner, removing that candidate from every voter's ballot + once they have been elected. + + Args: + profile (PreferenceProfile): PreferenceProfile to run election on. + m (int): Number of seats to elect. + """ + + def __init__(self, profile: PreferenceProfile, m: int): + if m <= 0: + raise ValueError("m must be positive.") + elif m > len(profile.candidates): + raise ValueError( + "m must be less than or equal to the number of candidates." + ) + + self.m = m + super().__init__(profile, score_function=first_place_votes) + + def _is_finished(self) -> bool: + cands_elected = [len(s) for s in self.get_elected()] + return sum(cands_elected) >= self.m + + def _run_step( + self, profile: PreferenceProfile, prev_state: ElectionState, store_states=False + ) -> PreferenceProfile: + """ + Run one step of an election from the given profile and previous state. + If m candidates have not yet been elected: + finds a single winning candidate to add to the list of elected + candidates by sampling from the distribution of first place votes. + Removes that candidate from all ballots in the preference profile. + + Args: + profile (PreferenceProfile): Profile of ballots. + prev_state (ElectionState): The previous ElectionState. + store_states (bool, optional): True if `self.election_states` should be updated with the + ElectionState generated by this round. This should only be True when used by + `self._run_election()`. Defaults to False. + + Returns: + PreferenceProfile: The profile of ballots after the round is completed. + """ + + ballots = profile.ballots + weights = [b.weight for b in ballots] + random_ballot = random.choices(ballots, weights=weights, k=1)[0] + + if not random_ballot.ranking: + return PreferenceProfile() + + if len(random_ballot.ranking[0]) > 1: + tiebroken_ranking = tiebreak_set( + random_ballot.ranking[0], tiebreak="random" + ) + tiebreaks = {random_ballot.ranking[0]: tiebroken_ranking} + + else: + tiebroken_ranking = (random_ballot.ranking[0],) + tiebreaks = {} + + winning_cand = list(tiebroken_ranking[0])[0] + elected = (frozenset({winning_cand}),) + + new_profile = remove_cand(winning_cand, profile) + + if store_states: + if self.score_function: + scores = self.score_function(new_profile) + remaining = score_dict_to_ranking(scores) + + new_state = ElectionState( + round_number=prev_state.round_number + 1, + elected=elected, + remaining=remaining, + scores=scores, + tiebreaks=tiebreaks, + ) + + self.election_states.append(new_state) + return new_profile diff --git a/src/votekit/elections/kev__init__.py b/src/votekit/elections/kev__init__.py deleted file mode 100644 index 4003995..0000000 --- a/src/votekit/elections/kev__init__.py +++ /dev/null @@ -1,21 +0,0 @@ -from .election_types import ( # noqa - STV, - SNTV, - SequentialRCV, - Bloc, - Borda, - Limited, - SNTV_STV_Hybrid, - TopTwo, - DominatingSets, - CondoBorda, - Plurality, - IRV, - HighestScore, - Cumulative, - RandomDictator, - BoostedRandomDictator, - PluralityVeto, -) - -from .transfers import fractional_transfer, random_transfer # noqa diff --git a/src/votekit/elections/kev_election_types.py b/src/votekit/elections/kev_election_types.py deleted file mode 100644 index be347c4..0000000 --- a/src/votekit/elections/kev_election_types.py +++ /dev/null @@ -1,1445 +0,0 @@ -from fractions import Fraction -import itertools as it -import random -import numpy as np -from typing import Callable, Optional, Union -from functools import lru_cache - -from ..models import Election -from ..election_state import ElectionState -from ..graphs.pairwise_comparison_graph import PairwiseComparisonGraph -from ..pref_profile import PreferenceProfile -from ..ballot import Ballot -from .transfers import fractional_transfer -from ..utils import ( - compute_votes, - remove_cand, - scores_into_set_list, - tie_broken_ranking, - elect_cands_from_set_ranking, - first_place_votes, - compute_scores_from_vector, - validate_score_vector, - borda_scores, - ballots_by_first_cand, -) - - -class STV(Election): - """ - Class for multi-winner STV elections. - - Args: - profile (PreferenceProfile): PreferenceProfile to run election on. - transfer (Callable): Transfer method (e.g. fractional transfer). - seats (int): Number of seats to be elected. - quota (str, optional): Formula to calculate quota. Accepts "droop" or "hare". - Defaults to "droop". - ballot_ties (bool, optional): Resolves input ballot ties if True, else assumes ballots have - no ties. Defaults to True. - tiebreak (Union[str, Callable], optional): Resolves procedural and final ties by specified - tiebreak. Can either be a custom tiebreak function or a string. Supported strings are - given in ``tie_broken_ranking`` documentation. The custom function must take as - input two named parameters; ``ranking``, a list-of-sets ranking of candidates and - ``profile``, the original ``PreferenceProfile``. It must return a list-of-sets - ranking of candidates with no ties. Defaults to random tiebreak. - - Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on. - state (ElectionState): Current state of the election. - transfer (Callable): Transfer method (e.g. fractional transfer). - seats (int): Number of seats to be elected. - quota (str): Formula to calculate quota. - tiebreak (Union[str, Callable]): Resolves procedural and final ties by specified - tiebreak. - threshold (int): Threshold number of votes to be elected. - - """ - - def __init__( - self, - profile: PreferenceProfile, - transfer: Callable, - seats: int, - quota: str = "droop", - ballot_ties: bool = True, - tiebreak: Union[str, Callable] = "random", - ): - # let parent class handle the og profile and election state - super().__init__(profile, ballot_ties) - - self.transfer = transfer - self.seats = seats - self.tiebreak = tiebreak - self.quota = quota.lower() - self.threshold = self.get_threshold() - - # can cache since it will not change throughout rounds - def get_threshold(self) -> int: - """ - Calculates threshold required for election. - - Returns: - int: Value of the threshold. - """ - quota = self.quota - if quota == "droop": - return int(self._profile.num_ballots() / (self.seats + 1) + 1) - elif quota == "hare": - return int(self._profile.num_ballots() / self.seats) - else: - raise ValueError("Misspelled or unknown quota type") - - def next_round(self) -> bool: - """ - Determines if the number of seats has been met to call an election. - - Returns: - bool: True if number of seats has not been met, False otherwise. - """ - cands_elected = 0 - for s in self.state.winners(): - cands_elected += len(s) - return cands_elected < self.seats - - def run_step(self) -> ElectionState: - """ - Simulates one round an STV election. - - Returns: - ElectionState: An ElectionState object for a round. - """ - remaining = self.state.profile.get_candidates() - ballots = self.state.profile.get_ballots() - round_votes, plurality_score = compute_votes(remaining, ballots) - - elected = [] - eliminated = [] - - # if number of remaining candidates equals number of remaining seats, - # everyone is elected - if len(remaining) == self.seats - len( - [c for s in self.state.winners() for c in s] - ): - elected = [{cand} for cand, _ in round_votes] - remaining = [] - ballots = [] - - # elect all candidates who crossed threshold - elif round_votes[0].votes >= self.threshold: - # partition ballots by first place candidate - cand_to_ballot = ballots_by_first_cand(remaining, ballots) - new_ballots = [] - for candidate, votes in round_votes: - if votes >= self.threshold: - elected.append({candidate}) - remaining.remove(candidate) - # only transfer on ballots where winner is first - new_ballots += self.transfer( - candidate, - cand_to_ballot[candidate], - plurality_score, - self.threshold, - ) - - # add in remaining ballots where non-winners are first - for cand in remaining: - new_ballots += cand_to_ballot[cand] - - # remove winners from all ballots - ballots = remove_cand([c for s in elected for c in s], new_ballots) - - # since no one has crossed threshold, eliminate one of the people - # with least first place votes - else: - lp_candidates = [ - candidate - for candidate, votes in round_votes - if votes == round_votes[-1].votes - ] - - if isinstance(self.tiebreak, str): - lp_cand = tie_broken_ranking( - ranking=[set(lp_candidates)], - profile=self.state.profile, - tiebreak=self.tiebreak, - )[-1] - else: - lp_cand = self.tiebreak( - ranking=[set(lp_candidates)], profile=self.state.profile - )[-1] - - eliminated.append(lp_cand) - ballots = remove_cand(lp_cand, ballots) - remaining.remove(next(iter(lp_cand))) - - # sorts remaining based on their current first place votes - _, score_dict = compute_votes(remaining, ballots) - remaining = scores_into_set_list(score_dict, remaining) - - # sort candidates by vote share if multiple are elected - if len(elected) >= 1: - elected = scores_into_set_list( - plurality_score, [c for s in elected for c in s] - ) - - # Make sure list-of-sets have non-empty elements - elected = [s for s in elected if s != set()] - eliminated = [s for s in eliminated if s != set()] - - self.state = ElectionState( - curr_round=self.state.curr_round + 1, - elected=elected, - eliminated_cands=eliminated, - remaining=remaining, - scores=score_dict, - profile=PreferenceProfile(ballots=ballots), - previous=self.state, - ) - return self.state - - @lru_cache - def run_election(self) -> ElectionState: - """ - Runs complete STV election. - - Returns: - ElectionState: An ElectionState object with results for a complete election. - """ - if not self.next_round(): - raise ValueError( - f"Length of elected set equal to number of seats ({self.seats})" - ) - - while self.next_round(): - self.run_step() - - return self.state - - -class Limited(Election): - """ - Elects m candidates with the highest k-approval scores. - The k-approval score of a candidate is equal to the number of voters who - rank this candidate among their k top ranked candidates. - - Args: - profile (PreferenceProfile): PreferenceProfile to run election on. - seats (int): Number of seats to be elected. - k (int): The number of top ranked candidates to consider as approved. - ballot_ties (bool, optional): Resolves input ballot ties if True, else assumes ballots have - no ties. Defaults to True. - tiebreak (Union[str, Callable], optional): Resolves procedural and final ties by specified - tiebreak. Can either be a custom tiebreak function or a string. Supported strings are - given in ``tie_broken_ranking`` documentation. The custom function must take as - input two named parameters; ``ranking``, a list-of-sets ranking of candidates and - ``profile``, the original ``PreferenceProfile``. It must return a list-of-sets - ranking of candidates with no ties. Defaults to random tiebreak. - - Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on. - state (ElectionState): Current state of the election. - seats (int): Number of seats to be elected. - k (int): The number of top ranked candidates to consider as approved. - tiebreak (Union[str, Callable]): Resolves procedural and final ties by specified - tiebreak. - - """ - - def __init__( - self, - profile: PreferenceProfile, - seats: int, - k: int, - ballot_ties: bool = True, - tiebreak: Union[Callable, str] = "random", - ): - super().__init__(profile, ballot_ties) - self.seats = seats - self.k = k - self.tiebreak = tiebreak - - def run_step(self) -> ElectionState: - """ - Conducts Limited election in which m candidates are elected based - on approval scores. - - Returns: - ElectionState: An ElectionState object for a Limited election. - """ - profile = self.state.profile - candidates = profile.get_candidates() - candidate_approvals = {c: Fraction(0) for c in candidates} - - for ballot in profile.get_ballots(): - # First we have to determine which candidates are approved - # i.e. in first k ranks on a ballot - approvals = [] - for i, cand_set in enumerate(ballot.ranking): - # If list of total candidates before and including current set - # are less than seat count, all candidates are approved - if len(list(it.chain(*ballot.ranking[: i + 1]))) < self.k: - approvals.extend(list(cand_set)) - # If list of total candidates before current set - # are greater than seat count, no candidates are approved - elif len(list(it.chain(*ballot.ranking[:i]))) > self.k: - approvals.extend([]) - # Else we know the cutoff is in the set, we compute and randomly - # select the number of candidates we can select - else: - # NOTE: I think I notice a bug here! If a single candidate is named 'ABC' this - # counts three candidates 'A', 'B', and 'C' -- i.e. it breaks up strings - accepted = len(list(it.chain(*ballot.ranking[:i]))) - num_to_allow = self.k - accepted - approvals.extend( - np.random.choice(list(cand_set), num_to_allow, replace=False) - ) - - # Add approval votes equal to ballot weight (i.e. number of voters with this ballot) - for cand in approvals: - candidate_approvals[cand] += ballot.weight - - # Order candidates by number of approval votes received - ranking = scores_into_set_list(candidate_approvals) - - if isinstance(self.tiebreak, str): - ranking = tie_broken_ranking( - ranking=ranking, profile=self.state.profile, tiebreak=self.tiebreak - ) - else: - ranking = self.tiebreak(ranking=ranking, profile=self.state.profile) - - elected, eliminated = elect_cands_from_set_ranking( - ranking=ranking, seats=self.seats - ) - new_state = ElectionState( - curr_round=self.state.curr_round + 1, - elected=elected, - eliminated_cands=eliminated, - remaining=list(), - scores=candidate_approvals, - profile=PreferenceProfile(), - previous=self.state, - ) - self.state = new_state - return self.state - - @lru_cache - def run_election(self) -> ElectionState: - """ - Simulates a complete Limited election. - - Returns: - ElectionState: An ElectionState object with results for a complete election. - """ - self.run_step() - return self.state - - -class Bloc(Limited): - """ - Elects m candidates with the highest m-approval scores. Specific case of Limited election - where k = m. - - Args: - profile (PreferenceProfile): PreferenceProfile to run election on. - seats (int): Number of seats to be elected. - ballot_ties (bool, optional): Resolves input ballot ties if True, else assumes ballots have - no ties. Defaults to True. - tiebreak (Union[str, Callable], optional): Resolves procedural and final ties by specified - tiebreak. Can either be a custom tiebreak function or a string. Supported strings are - given in ``tie_broken_ranking`` documentation. The custom function must take as - input two named parameters; ``ranking``, a list-of-sets ranking of candidates and - ``profile``, the original ``PreferenceProfile``. It must return a list-of-sets - ranking of candidates with no ties. Defaults to random tiebreak. - - Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on. - state (ElectionState): Current state of the election. - seats (int): Number of seats to be elected. - tiebreak (Union[str, Callable]): Resolves procedural and final ties by specified - tiebreak. - """ - - def __init__( - self, - profile: PreferenceProfile, - seats: int, - ballot_ties: bool = True, - tiebreak: Union[Callable, str] = "random", - ): - super().__init__(profile, seats, seats, ballot_ties, tiebreak) - - -class SNTV(Limited): - """ - Single nontransferable vote (SNTV): Elects k candidates with the highest - Plurality scores. Equivalent to Limited with k=1. - - Args: - profile (PreferenceProfile): PreferenceProfile to run election on. - seats (int): Number of seats to be elected. - ballot_ties (bool, optional): Resolves input ballot ties if True, else assumes ballots have - no ties. Defaults to True. - tiebreak (Union[str, Callable], optional): Resolves procedural and final ties by specified - tiebreak. Can either be a custom tiebreak function or a string. Supported strings are - given in ``tie_broken_ranking`` documentation. The custom function must take as - input two named parameters; ``ranking``, a list-of-sets ranking of candidates and - ``profile``, the original ``PreferenceProfile``. It must return a list-of-sets - ranking of candidates with no ties. Defaults to random tiebreak. - - Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on. - state (ElectionState): Current state of the election. - seats (int): Number of seats to be elected. - tiebreak (Union[str, Callable]): Resolves procedural and final ties by specified - tiebreak. - """ - - def __init__( - self, - profile: PreferenceProfile, - seats: int, - ballot_ties: bool = True, - tiebreak: Union[Callable, str] = "random", - ): - super().__init__(profile, seats, 1, ballot_ties, tiebreak) - - -class Plurality(SNTV): - """ - Simulates a single or multi-winner plurality election. Wrapper for SNTV. - """ - - -class SNTV_STV_Hybrid(Election): - """ - Election method that first runs SNTV to a cutoff number of candidates, then runs STV to - pick a committee with a given number of seats. - - Args: - profile (PreferenceProfile): PreferenceProfile to run election on. - transfer (Callable): Transfer method (e.g. fractional transfer). - r1_cutoff (int): First round cutoff value. - seats (int): Number of seats to be elected. - ballot_ties (bool, optional): Resolves input ballot ties if True, else assumes ballots have - no ties. Defaults to True. - tiebreak (Union[str, Callable], optional): Resolves procedural and final ties by specified - tiebreak. Can either be a custom tiebreak function or a string. Supported strings are - given in ``tie_broken_ranking`` documentation. The custom function must take as - input two named parameters; ``ranking``, a list-of-sets ranking of candidates and - ``profile``, the original ``PreferenceProfile``. It must return a list-of-sets - ranking of candidates with no ties. Defaults to random tiebreak. - - Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on. - state (ElectionState): Current state of the election. - transfer (Callable): Transfer method (e.g. fractional transfer). - r1_cutoff (int): First round cutoff value. - seats (int): Number of seats to be elected. - tiebreak (Union[str, Callable]): Resolves procedural and final ties by specified - tiebreak. - - - """ - - def __init__( - self, - profile: PreferenceProfile, - transfer: Callable, - r1_cutoff: int, - seats: int, - ballot_ties: bool = True, - tiebreak: Union[Callable, str] = "random", - ): - super().__init__(profile, ballot_ties) - self.transfer = transfer - self.r1_cutoff = r1_cutoff - self.seats = seats - self.tiebreak = tiebreak - self.stage = "SNTV" # SNTV, switches to STV, then Complete - - def run_step(self, stage: str) -> ElectionState: - """ - Simulates one round an SNTV_STV election. - - Args: - stage (str): Stage of the hybrid election, can be "SNTV" or "STV". - - Returns: - ElectionState: An ElectionState object for a given round. - """ - profile = self.state.profile - - new_state = None - if stage == "SNTV": - round_state = SNTV( - profile=profile, seats=self.r1_cutoff, tiebreak=self.tiebreak - ).run_election() - - # The STV election will be run on the new election state - # Therefore we should not add any winners, but rather - # set the SNTV winners as remaining candidates and update pref profiles - new_profile = PreferenceProfile( - ballots=remove_cand( - set().union(*round_state.eliminated_cands), profile.get_ballots() - ) - ) - new_state = ElectionState( - curr_round=self.state.curr_round + 1, - elected=list(), - eliminated_cands=round_state.eliminated_cands, - remaining=[set(new_profile.get_candidates())], - profile=new_profile, - scores=round_state.get_scores(round_state.curr_round), - previous=self.state, - ) - elif stage == "STV": - round_state = STV( - profile=profile, - transfer=self.transfer, - seats=self.seats, - tiebreak=self.tiebreak, - ).run_election() - - new_state = ElectionState( - curr_round=self.state.curr_round + 1, - elected=round_state.winners(), - eliminated_cands=round_state.eliminated(), - remaining=round_state.remaining, - scores=round_state.get_scores(round_state.curr_round), - profile=round_state.profile, - previous=self.state, - ) - - # Update election stage to cue next run step - if stage == "SNTV": - self.stage = "STV" - elif stage == "STV": - self.stage = "Complete" - - self.state = new_state # type: ignore - return new_state # type: ignore - - @lru_cache - def run_election(self) -> ElectionState: - """ - Runs complete SNTV_STV election. - - Returns: - ElectionState: An ElectionState object with results for a complete election. - """ - while self.stage != "Complete": - self.run_step(self.stage) - return self.state # type: ignore - - -class TopTwo(Election): - """ - Eliminates all but the top two plurality vote getters, and then - conducts a runoff between them, reallocating other ballots. - - Args: - profile (PreferenceProfile): PreferenceProfile to run election on. - seats (int): Number of seats to be elected. - ballot_ties (bool, optional): Resolves input ballot ties if True, else assumes ballots have - no ties. Defaults to True. - tiebreak (Union[str, Callable], optional): Resolves procedural and final ties by specified - tiebreak. Can either be a custom tiebreak function or a string. Supported strings are - given in ``tie_broken_ranking`` documentation. The custom function must take as - input two named parameters; ``ranking``, a list-of-sets ranking of candidates and - ``profile``, the original ``PreferenceProfile``. It must return a list-of-sets - ranking of candidates with no ties. Defaults to random tiebreak. - - Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on. - state (ElectionState): Current state of the election. - seats (int): Number of seats to be elected. - tiebreak (Union[str, Callable]): Resolves procedural and final ties by specified - tiebreak. - """ - - def __init__( - self, - profile: PreferenceProfile, - ballot_ties: bool = True, - tiebreak: Union[str, Callable] = "random", - ): - super().__init__(profile, ballot_ties) - self.tiebreak = tiebreak - - def run_step(self) -> ElectionState: - """ - Conducts a TopTwo election for one seat with a cutoff of 2 for the runoff. - - Returns: - ElectionState: An ElectionState object for the TopTwo election. - """ - hybrid_equivalent = SNTV_STV_Hybrid( - profile=self.state.profile, - transfer=fractional_transfer, - r1_cutoff=2, - seats=1, - tiebreak=self.tiebreak, - ) - outcome = hybrid_equivalent.run_election() - self.state = outcome - return outcome - - @lru_cache - def run_election(self) -> ElectionState: - """ - Simulates a complete TopTwo election. - - Returns: - ElectionState: An ElectionState object for a complete election. - """ - self.run_step() - return self.state - - -class DominatingSets(Election): - """ - Finds tiers of candidates by dominating set, which is a set of candidates - such that every candidate in the set wins head to head comparisons against - candidates outside of it. Elects all candidates in the top tier. - - Args: - profile (PreferenceProfile): PreferenceProfile to run election on. - ballot_ties (bool, optional): Resolves input ballot ties if True, else assumes ballots have - no ties. Defaults to True. - - Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on. - state (ElectionState): Current state of the election. - """ - - def __init__(self, profile: PreferenceProfile, ballot_ties: bool = True): - super().__init__(profile, ballot_ties) - - def run_step(self) -> ElectionState: - """ - Conducts a complete DominatingSets election as it is not a round-by-round - system. - - Returns: - ElectionState: An ElectionState object for a complete election. - """ - pwc_graph = PairwiseComparisonGraph(self.state.profile) - dominating_tiers = pwc_graph.dominating_tiers() - if len(dominating_tiers) == 1: - new_state = ElectionState( - curr_round=self.state.curr_round + 1, - elected=list(), - eliminated_cands=dominating_tiers, - remaining=list(), - scores=pwc_graph.pairwise_dict, - profile=PreferenceProfile(), - previous=self.state, - ) - else: - new_state = ElectionState( - curr_round=self.state.curr_round + 1, - elected=[set(dominating_tiers[0])], - eliminated_cands=dominating_tiers[1:], - remaining=list(), - scores=pwc_graph.pairwise_dict, - profile=PreferenceProfile(), - previous=self.state, - ) - self.state = new_state - return new_state - - @lru_cache - def run_election(self) -> ElectionState: - """ - Simulates a complete DominatingSets election. - - Returns: - ElectionState: An ElectionState object for a complete election. - """ - self.run_step() - return self.state - - -class CondoBorda(Election): - """ - Finds tiers of candidates by dominating set, which is a set of candidates - such that every candidate in the set wins head to head comparisons against - candidates outside of it. Elects as many candidates as specified, in order from - first to last dominating set. If the number of seats left is smaller than the next - dominating set, CondoBorda breaks ties between candidates with Borda. - - Args: - profile (PreferenceProfile): PreferenceProfile to run election on. - seats (int): Number of seats to be elected. - ballot_ties (bool, optional): Resolves input ballot ties if True, else assumes ballots have - no ties. Defaults to True. - tiebreak (Union[str, Callable], optional): Resolves procedural and final ties by specified - tiebreak. Can either be a custom tiebreak function or a string. Supported strings are - given in ``tie_broken_ranking`` documentation. The custom function must take as - input two named parameters; ``ranking``, a list-of-sets ranking of candidates and - ``profile``, the original ``PreferenceProfile``. It must return a list-of-sets - ranking of candidates with no ties. Defaults to random tiebreak. - - Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on. - state (ElectionState): Current state of the election. - seats (int): Number of seats to be elected. - tiebreak (Union[str, Callable]): Resolves procedural and final ties by specified - tiebreak. - """ - - def __init__( - self, - profile: PreferenceProfile, - seats: int, - ballot_ties: bool = True, - tiebreak: Union[Callable, str] = "random", - ): - super().__init__(profile, ballot_ties) - self.seats = seats - self.tiebreak = tiebreak - - def run_step(self) -> ElectionState: - """ - Conducts a complete Conda-Borda election as it is not a round-by-round - system. - - Returns: - ElectionState: An `ElectionState` object for a complete election. - """ - pwc_graph = PairwiseComparisonGraph(self.state.profile) - dominating_tiers = pwc_graph.dominating_tiers() - - if isinstance(self.tiebreak, str): - ranking = tie_broken_ranking( - ranking=dominating_tiers, profile=self.state.profile, tiebreak="borda" - ) - else: - ranking = self.tiebreak( - ranking=dominating_tiers, profile=self.state.profile - ) - - elected, eliminated = elect_cands_from_set_ranking( - ranking=ranking, seats=self.seats - ) - - new_state = ElectionState( - curr_round=self.state.curr_round + 1, - elected=elected, - eliminated_cands=eliminated, - remaining=list(), - scores=pwc_graph.pairwise_dict, - profile=PreferenceProfile(), - previous=self.state, - ) - self.state = new_state - return new_state - - @lru_cache - def run_election(self) -> ElectionState: - """ - Simulates a complete Conda-Borda election. - - Returns: - ElectionState: An ElectionState object for a complete election. - """ - self.run_step() - return self.state - - -class SequentialRCV(Election): - """ - Class to conduct Sequential RCV election, in which votes are not transferred - after a candidate has reached threshold, or been elected. - - Args: - profile (PreferenceProfile): PreferenceProfile to run election on. - seats (int): Number of seats to be elected. - ballot_ties (bool, optional): Resolves input ballot ties if True, else assumes ballots have - no ties. Defaults to True. - tiebreak (Union[str, Callable], optional): Resolves procedural and final ties by specified - tiebreak. Can either be a custom tiebreak function or a string. Supported strings are - given in ``tie_broken_ranking`` documentation. The custom function must take as - input two named parameters; ``ranking``, a list-of-sets ranking of candidates and - ``profile``, the original ``PreferenceProfile``. It must return a list-of-sets - ranking of candidates with no ties. Defaults to random tiebreak. - - Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on. - state (ElectionState): Current state of the election. - seats (int): Number of seats to be elected. - tiebreak (Union[str, Callable]): Resolves procedural and final ties by specified - tiebreak. - """ - - def __init__( - self, - profile: PreferenceProfile, - seats: int, - ballot_ties: bool = True, - tiebreak: Union[Callable, str] = "random", - ): - super().__init__(profile, ballot_ties) - self.seats = seats - self.tiebreak = tiebreak - - def run_step(self, old_profile: PreferenceProfile) -> ElectionState: - """ - Simulates a single step of the sequential RCV contest or a full - IRV election run on the current set of candidates. - - Returns: - ElectionState: An ElectionState object. - """ - old_election_state = self.state - - IRVrun = STV( - old_profile, - transfer=(lambda winner, ballots, votes, threshold: ballots), - seats=1, - tiebreak=self.tiebreak, - ) - old_election = IRVrun.run_election() - elected_cand = old_election.winners()[0] - - # Removes elected candidate from Ballot List - updated_ballots = remove_cand(elected_cand, old_profile.get_ballots()) - - # Updates profile with removed candidates - updated_profile = PreferenceProfile(ballots=updated_ballots) - - self.state = ElectionState( - curr_round=old_election_state.curr_round + 1, - elected=[elected_cand], - profile=updated_profile, - previous=old_election_state, - scores=first_place_votes(updated_profile), - remaining=old_election.remaining, - ) - return self.state - - @lru_cache - def run_election(self) -> ElectionState: - """ - Simulates a complete sequential RCV contest. - - Returns: - ElectionState: An ElectionState object for a complete election. - """ - old_profile = self._profile - elected = [] # type: ignore - seqRCV_step = self.state - - while len(elected) < self.seats: - seqRCV_step = self.run_step(old_profile) - elected.append(seqRCV_step.elected) - old_profile = seqRCV_step.profile - return seqRCV_step - - -class Borda(Election): - """ - Positional voting system that assigns a decreasing number of points to - candidates based on order and a score vector. The conventional score - vector is :math:`(n, n-1, \dots, 1)`, where `n` is the number of candidates. - If a ballot is incomplete, the remaining points of the score vector - are evenly distributed to the unlisted candidates (see ``borda_scores`` function in ``utils``). - - Args: - profile (PreferenceProfile): PreferenceProfile to run election on. - seats (int): Number of seats to be elected. - score_vector (list[Fraction], optional): Weights assigned to candidate ranking. - Defaults to :math:`(n,n-1,\dots,1)`. - ballot_ties (bool, optional): Resolves input ballot ties if True, else assumes ballots have - no ties. Defaults to True. - tiebreak (Union[str, Callable], optional): Resolves procedural and final ties by specified - tiebreak. Can either be a custom tiebreak function or a string. Supported strings are - given in ``tie_broken_ranking`` documentation. The custom function must take as - input two named parameters; ``ranking``, a list-of-sets ranking of candidates and - ``profile``, the original ``PreferenceProfile``. It must return a list-of-sets - ranking of candidates with no ties. Defaults to random tiebreak. - - Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on. - state (ElectionState): Current state of the election. - seats (int): Number of seats to be elected. - score_vector (list[Fraction], optional): Weights assigned to candidate ranking. - tiebreak (Union[str, Callable]): Resolves procedural and final ties by specified - tiebreak. - """ - - def __init__( - self, - profile: PreferenceProfile, - seats: int, - score_vector: Optional[list[Fraction]] = None, - ballot_ties: bool = True, - tiebreak: Union[Callable, str] = "random", - ): - super().__init__(profile, ballot_ties) - self.seats = seats - self.tiebreak = tiebreak - self.score_vector = score_vector - - def run_step(self) -> ElectionState: - """ - Simulates a complete Borda contest as Borda is not a round-by-round - system. - - Returns: - ElectionState: An ElectionState object for a complete election. - """ - borda_dict = borda_scores( - profile=self.state.profile, score_vector=self.score_vector - ) - - ranking = scores_into_set_list(borda_dict) - - if isinstance(self.tiebreak, str): - ranking = tie_broken_ranking( - ranking=ranking, profile=self.state.profile, tiebreak=self.tiebreak - ) - else: - ranking = self.tiebreak(ranking=ranking, profile=self.state.profile) - - elected, eliminated = elect_cands_from_set_ranking( - ranking=ranking, seats=self.seats - ) - - new_state = ElectionState( - curr_round=self.state.curr_round + 1, - elected=elected, - eliminated_cands=eliminated, - remaining=list(), - scores=borda_dict, - profile=PreferenceProfile(), - previous=self.state, - ) - self.state = new_state - return new_state - - @lru_cache - def run_election(self) -> ElectionState: - """ - Simulates a complete Borda contest. - - Returns: - ElectionState: An ElectionState object for a complete election. - """ - self.run_step() - return self.state - - -class IRV(STV): - """ - A class for conducting IRV elections, which are mathematically equivalent to STV for one seat. - - Args: - profile (PreferenceProfile): PreferenceProfile to run election on. - seats (int): Number of seats to be elected. - quota (str, optional): Formula to calculate quota. Accepts "droop" or "hare". - Defaults to "droop". - ballot_ties (bool, optional): Resolves input ballot ties if True, else assumes ballots have - no ties. Defaults to True. - tiebreak (Union[str, Callable], optional): Resolves procedural and final ties by specified - tiebreak. Can either be a custom tiebreak function or a string. Supported strings are - given in ``tie_broken_ranking`` documentation. The custom function must take as - input two named parameters; ``ranking``, a list-of-sets ranking of candidates and - ``profile``, the original ``PreferenceProfile``. It must return a list-of-sets - ranking of candidates with no ties. Defaults to random tiebreak. - - Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on. - state (ElectionState): Current state of the election. - seats (int): Number of seats to be elected. - quota (str): Formula to calculate quota. - tiebreak (Union[str, Callable]): Resolves procedural and final ties by specified - tiebreak. - threshold (int): Threshold number of votes to be elected. - - """ - - def __init__( - self, - profile: PreferenceProfile, - quota: str = "droop", - ballot_ties: bool = True, - tiebreak: Union[Callable, str] = "random", - ): - # let parent class handle the construction - super().__init__( - profile=profile, - ballot_ties=ballot_ties, - seats=1, - tiebreak=tiebreak, - quota=quota, - transfer=fractional_transfer, - ) - - -class HighestScore(Election): - """ - Conducts an election based on points from score vector. - Chooses the m candidates with highest scores. - Ties are broken by randomly permuting the tied candidates. - - Args: - profile (PreferenceProfile): PreferenceProfile to run election on. - seats (int): Number of seats to be elected. - score_vector (list[float]): List of floats where `i`th entry denotes the number of points - given to candidates ranked in position `i`. - ballot_ties (bool, optional): Resolves input ballot ties if True, else assumes ballots have - no ties. Defaults to True. - tiebreak (Union[str, Callable], optional): Resolves procedural and final ties by specified - tiebreak. Can either be a custom tiebreak function or a string. Supported strings are - given in ``tie_broken_ranking`` documentation. The custom function must take as - input two named parameters; ``ranking``, a list-of-sets ranking of candidates and - ``profile``, the original ``PreferenceProfile``. It must return a list-of-sets - ranking of candidates with no ties. Defaults to random tiebreak. - - Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on. - state (ElectionState): Current state of the election. - seats (int): Number of seats to be elected. - score_vector (list[float]): List of floats where `i`th entry denotes the number of points - given to candidates ranked in position `i`. - tiebreak (Union[str, Callable]): Resolves procedural and final ties by specified - tiebreak. - - """ - - def __init__( - self, - profile: PreferenceProfile, - seats: int, - score_vector: list[float], - tiebreak: Union[Callable, str] = "random", - ballot_ties: bool = False, - ): - super().__init__(profile, ballot_ties) - # check for valid score vector - validate_score_vector(score_vector) - - self.seats = seats - self.score_vector = score_vector - self.tiebreak = tiebreak - - def run_step(self): - """ - Simulates a complete Borda contest as Borda is not a round-by-round - system. - - Returns: - ElectionState: An ElectionState object for a complete election. - """ - # a dictionary whose keys are candidates and values are scores - vote_tallies = compute_scores_from_vector( - profile=self.state.profile, score_vector=self.score_vector - ) - - # translate scores into ranking of candidates, tie break - ranking = scores_into_set_list(score_dict=vote_tallies) - - if isinstance(self.tiebreak, str): - untied_ranking = tie_broken_ranking( - ranking=ranking, profile=self.state.profile, tiebreak=self.tiebreak - ) - else: - untied_ranking = self.tiebreak(ranking=ranking, profile=self.state.profile) - - elected, eliminated = elect_cands_from_set_ranking( - ranking=untied_ranking, seats=self.seats - ) - - self.state = ElectionState( - curr_round=1, - elected=elected, - eliminated_cands=eliminated, - remaining=[], - profile=self.state.profile, - previous=self.state, - ) - return self.state - - @lru_cache - def run_election(self): - """ - Simulates a complete Borda contest. - - Returns: - ElectionState: An ElectionState object for a complete election. - """ - self.run_step() - return self.state - - -class Cumulative(HighestScore): - """ - Voting system where voters are allowed to vote for candidates with multiplicity. - Each ranking position should have one candidate, and every candidate ranked will receive - one point, i.e., the score vector is :math:`(1,\dots,1)`. - - Args: - profile (PreferenceProfile): PreferenceProfile to run election on. - seats (int): Number of seats to be elected. - ballot_ties (bool, optional): Resolves input ballot ties if True, else assumes ballots have - no ties. Defaults to True. - tiebreak (Union[str, Callable], optional): Resolves procedural and final ties by specified - tiebreak. Can either be a custom tiebreak function or a string. Supported strings are - given in ``tie_broken_ranking`` documentation. The custom function must take as - input two named parameters; ``ranking``, a list-of-sets ranking of candidates and - ``profile``, the original ``PreferenceProfile``. It must return a list-of-sets - ranking of candidates with no ties. Defaults to random tiebreak. - - Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on. - state (ElectionState): Current state of the election. - seats (int): Number of seats to be elected. - tiebreak (Union[str, Callable]): Resolves procedural and final ties by specified - tiebreak. - """ - - def __init__( - self, - profile: PreferenceProfile, - seats: int, - ballot_ties: bool = True, - tiebreak: Union[str, Callable] = "random", - ): - longest_ballot = 0 - for ballot in profile.ballots: - if len(ballot.ranking) > longest_ballot: - longest_ballot = len(ballot.ranking) - - score_vector = [1.0 for _ in range(longest_ballot)] - super().__init__( - profile=profile, - ballot_ties=ballot_ties, - score_vector=score_vector, - seats=seats, - tiebreak=tiebreak, - ) - - -class RandomDictator(Election): - """ - Choose a winner randomly from the distribution of first place votes. For multi-winner elections - repeat this process for every winner, removing that candidate from every voter's ballot - once they have been elected. - - Args: - profile (PreferenceProfile): PreferenceProfile to run election on. - m (int): Number of seats to elect. - - Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on. - m (int): Number of seats to be elected. - - """ - - def __init__(self, profile: PreferenceProfile, m: int): - super().__init__(profile, ballot_ties=False) - if m <= 0 or m > len(profile.get_candidates()): - raise ValueError("Invalid number of candidates to elect") - - self.m = m - - def next_round(self) -> bool: - """ - Determines if another round is needed. - - Returns: - (bool) True if number of seats has not been met, False otherwise. - """ - cands_elected = [len(s) for s in self.state.winners()] - return sum(cands_elected) < self.m - - def run_step(self): - """ - If m candidates have not yet been elected: - finds a single winning candidate to add to the list of elected - candidates by sampling from the distribution of first place votes. - Removes that candidate from all ballots in the preference profile. - - Returns: - ElectionState: An ElectionState object for a complete election. - """ - if self.next_round(): - remaining = self.state.profile.get_candidates() - - ballots = self.state.profile.ballots - weights = [b.weight for b in ballots] - random_ballot = random.choices( - self.state.profile.ballots, weights=weights, k=1 - )[0] - - winning_candidate = random.choice(list(random_ballot.ranking[0])) - elected = [{winning_candidate}] - new_ballots = remove_cand(winning_candidate, self.state.profile.ballots) - new_profile = PreferenceProfile(ballots=new_ballots) - remaining = [{c} for c in remaining if c != winning_candidate] - - self.state = ElectionState( - curr_round=self.state.curr_round + 1, - elected=elected, - eliminated_cands=[], - remaining=remaining, - profile=new_profile, - previous=self.state, - ) - return self.state - - def run_election(self): - # run steps until we elect the required number of candidates - while self.next_round(): - self.run_step() - - return self.state - - -class BoostedRandomDictator(Election): - """ - Modified random dictator where - - With probability (1 - 1/(n_candidates - 1)) - choose a winner randomly from the distribution of first place votes. - - With probability 1/(n_candidates - 1) - Choose a winner via a proportional to squares rule. - - For multi-winner elections - repeat this process for every winner, removing that candidate from every - voter's ballot once they have been elected. - - Args: - profile (PreferenceProfile): PreferenceProfile to run election on. - m (int): Number of seats to elect. - - Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on. - m (int): Number of seats to be elected. - - """ - - def __init__(self, profile: PreferenceProfile, m: int): - super().__init__(profile, ballot_ties=False) - if m <= 0 or m > len(profile.get_candidates()): - raise ValueError("Invalid number of candidates to elect") - - self.m = m - - def next_round(self) -> bool: - """ - Determines if another round is needed. - - Returns: - (bool) True if number of seats has not been met, False otherwise. - """ - cands_elected = [len(s) for s in self.state.winners()] - return sum(cands_elected) < self.m - - def run_step(self): - """ - If m candidates have not yet been elected: - finds a single winning candidate to add to the list of elected - candidates by sampling from the distribution induced by the combination - of random dictator and proportional to squares election rules. - Removes that candidate from all ballots in the preference profile. - - Returns: - ElectionState: An ElectionState object for a complete election. - """ - if self.next_round(): - remaining = self.state.profile.get_candidates() - u = random.uniform(0, 1) - - if len(remaining) == 1: - winning_candidate = remaining[0] - - elif u <= 1 / (len(remaining) - 1): - candidate_votes = first_place_votes(self.state.profile, to_float=True) - p = np.array([i for i in candidate_votes.values()]) - p /= float(self.state.profile.num_ballots()) - p = np.power(p, 2) - p /= np.sum(p) - winning_candidate = np.random.choice(remaining, p=p) - - else: - ballots = self.state.profile.ballots - weights = [b.weight for b in ballots] - random_ballot = random.choices( - self.state.profile.ballots, weights=weights, k=1 - )[0] - winning_candidate = random.choice(list(random_ballot.ranking[0])) - - elected = [{winning_candidate}] - new_ballots = remove_cand(winning_candidate, self.state.profile.ballots) - new_profile = PreferenceProfile(ballots=new_ballots) - remaining = [{c} for c in remaining if c != winning_candidate] - - self.state = ElectionState( - curr_round=self.state.curr_round + 1, - elected=elected, - eliminated_cands=[], - remaining=remaining, - profile=new_profile, - previous=self.state, - ) - return self.state - - def run_election(self): - while self.next_round(): - self.run_step() - - return self.state - - -class PluralityVeto(Election): - """ - Scores each candidate by their plurality (number of first) place votes, - then in a randomized order it lets each voter decrement the score of their - least favorite candidate. The candidate with the largest score at the end is - then chosen as the winner. - - Args: - profile (PreferenceProfile): PreferenceProfile to run election on. Note that - ballots muts have integer weights to be considered valid for this mechanism. - m (int): Number of seats to elect. - - Attributes: - _profile (PreferenceProfile): PreferenceProfile to run election on. - m (int): Number of seats to be elected. - random_order (list[int]): randomly shuffled order of voter indices - candidate_approvals (dict[str,int]): dictionary tracking current candidate scores - - - """ - - def __init__(self, profile: PreferenceProfile, m: int): - super().__init__(profile, ballot_ties=False) - if m <= 0 or m > len(profile.get_candidates()): - raise ValueError("Invalid number of candidates to elect.") - - self.m = m - - # Decondense ballots - ballots = self.state.profile.get_ballots() - new_ballots = [Ballot() for i in range(int(self.state.profile.num_ballots()))] - bidx = 0 - for i, b in enumerate(ballots): - if not int(b.weight) == b.weight: - raise ValueError("Ballots must have integer weight.") - - for j in range(int(b.weight)): - new_ballots[bidx] = Ballot(b.ranking, weight=Fraction(1, 1)) - bidx += 1 - - new_profile = PreferenceProfile( - ballots=new_ballots, candidates=self.state.profile.get_candidates() - ) - - self.state = ElectionState( - curr_round=self.state.curr_round, - elected=[], - eliminated_cands=[], - remaining=self.state.remaining, - profile=new_profile, - previous=self.state.previous, - ) - - self.random_order = None - self.candidate_approvals = None - - def next_round(self) -> bool: - """ - Determines if another round is needed. - - Returns: - (bool) True if number of seats has not been met, False otherwise. - """ - cands_elected = [len(s) for s in self.state.winners()] - return sum(cands_elected) < self.m - - def run_step(self): - """ - If m candidates have not yet been elected: - if the current round is 0, count plurality scores and remove all - candidates with a score of 0 to eliminated. Otherwise, this method - eliminates a single candidate by decrementing scores of candidates on - the current ticket until someone falls to a score of 0. Once we find - that there are exactly m candidates remaining on the ticket, elect all - of them. - - Returns: - ElectionState: An ElectionState object for a complete election. - """ - if self.next_round(): - candidates = self.state.profile.get_candidates() - ballots = self.state.profile.get_ballots() - - if len(candidates) == self.m: - # move all to elected, this is the last round - elected = [{c} for c in candidates] - self.state = ElectionState( - curr_round=self.state.curr_round + 1, - elected=elected, - eliminated_cands=[], - remaining=[], - profile=self.state.profile, - previous=self.state, - ) - - else: - if self.state.curr_round == 0: - eliminated = [ - c for c, score in self.candidate_approvals.items() if score <= 0 - ] - - else: - eliminated = ["c"] - last_idx = 0 - for i in range(len(self.random_order)): - last_idx = i - r = self.random_order[i] - ballot = ballots[r] - # Need to make a random choice between last place candidates, - # because voters should only get one veto - # if len(ballot.ranking) > 0: - least_preferred = random.choice(list(ballot.ranking[-1])) - self.candidate_approvals[least_preferred] -= 1 - if self.candidate_approvals[least_preferred] <= 0: - eliminated[0] = least_preferred - # Only want to eliminate one candidate per round so we break here - break - - # Update the randomized order so that - # we can continue where we left off next round - self.random_order = ( - self.random_order[last_idx + 1 :] - + self.random_order[: last_idx + 1] - ) - - new_ballots = remove_cand(eliminated, self.state.profile.ballots) - new_profile = PreferenceProfile(ballots=new_ballots) - eliminated = [{c} for c in eliminated] - remaining = [{c} for c in new_profile.get_candidates()] - self.state = ElectionState( - curr_round=self.state.curr_round + 1, - elected=[], - eliminated_cands=eliminated, - remaining=remaining, - profile=new_profile, - previous=self.state, - ) - - return self.state - - def run_election(self): - self.random_order = list(range(int(self.state.profile.num_ballots()))) - np.random.shuffle(self.random_order) - self.candidate_approvals = first_place_votes(self.state.profile, to_float=True) - - while self.next_round(): - self.run_step() - - return self.state diff --git a/tests/data/csv/test_pref_profile_to_csv.csv b/tests/data/csv/test_pref_profile_to_csv.csv index 152a5a5..36229fa 100644 --- a/tests/data/csv/test_pref_profile_to_csv.csv +++ b/tests/data/csv/test_pref_profile_to_csv.csv @@ -1,4 +1,4 @@ weight,ranking,scores 1.0,"({'A'}, {'B'})",() 1.5,"({'A'}, {'B'})",() -2.0,"({'B', 'C'},)",() +2.0,"({'C', 'B'},)",() diff --git a/tests/elections/election_types/ranking/test_boosted_random_dictator.py b/tests/elections/election_types/ranking/test_boosted_random_dictator.py new file mode 100644 index 0000000..77834f7 --- /dev/null +++ b/tests/elections/election_types/ranking/test_boosted_random_dictator.py @@ -0,0 +1,32 @@ +from votekit import Ballot, PreferenceProfile +from votekit.elections import BoostedRandomDictator +import random +import numpy as np + + +# TODO make tests in line with other election types +def test_boosted_random_dictator(): + # set seed for more predictable results + random.seed(919717) + + # simple 3 candidate election + candidates = ["A", "B", "C"] + ballots = [ + Ballot(ranking=[{"A"}, {"B"}, {"C"}], weight=3), + Ballot(ranking=[{"B"}, {"A"}, {"C"}]), + Ballot(ranking=[{"C"}, {"B"}, {"A"}]), + ] + test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) + + # count the number of wins over a set of trials + winner_counts = {c: 0 for c in candidates} + trials = 3000 + for t in range(trials): + election = BoostedRandomDictator(test_profile, 1) + winner = list(election.get_elected()[0])[0] + winner_counts[winner] += 1 + + # check to make sure that the fraction of wins matches the true probability + assert np.allclose( + 1 / 2 * 3 / 5 + 1 / 2 * 9 / 11, winner_counts["A"] / trials, atol=1e-2 + ) diff --git a/tests/elections/election_types/ranking/test_plurality_veto.py b/tests/elections/election_types/ranking/test_plurality_veto.py new file mode 100644 index 0000000..ff937e0 --- /dev/null +++ b/tests/elections/election_types/ranking/test_plurality_veto.py @@ -0,0 +1,35 @@ +from votekit import Ballot, PreferenceProfile +from votekit.elections import PluralityVeto +import random +import numpy as np + + +# TODO make tests in line with other election types +def test_plurality_veto(): + random.seed(919717) + + # simple 3 candidate election + candidates = ["A", "B", "C"] + # With every possible permutation of candidates, we should + # see that each candidate wins with probability 1/3 + ballots = [ + Ballot(ranking=[{"A"}, {"B"}, {"C"}]), + Ballot(ranking=[{"A"}, {"C"}, {"B"}]), + Ballot(ranking=[{"B"}, {"A"}, {"C"}]), + Ballot(ranking=[{"B"}, {"C"}, {"A"}]), + Ballot(ranking=[{"C"}, {"B"}, {"A"}]), + Ballot(ranking=[{"C"}, {"A"}, {"B"}]), + ] + test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) + + # count the number of wins over a set of trials + winner_counts = {c: 0 for c in candidates} + trials = 10000 + for t in range(trials): + election = PluralityVeto(test_profile, 1) + election.run_election() + winner = list(election.state.winners()[0])[0] + winner_counts[winner] += 1 + + # check to make sure that the fraction of wins matches the true probability + assert np.allclose(1 / 3, winner_counts["A"] / trials, atol=1e-2) diff --git a/tests/elections/election_types/ranking/test_random_dictator.py b/tests/elections/election_types/ranking/test_random_dictator.py new file mode 100644 index 0000000..4236aaf --- /dev/null +++ b/tests/elections/election_types/ranking/test_random_dictator.py @@ -0,0 +1,30 @@ +from votekit import PreferenceProfile, Ballot +from votekit.elections import RandomDictator +import numpy as np +import random + + +# TODO make tests in line with other election types +def test_random_dictator(): + # set seed for more predictable results + random.seed(919717) + + # simple 3 candidate election + candidates = ["A", "B", "C"] + ballots = [ + Ballot(ranking=[{"A"}, {"B"}, {"C"}], weight=3), + Ballot(ranking=[{"B"}, {"A"}, {"C"}]), + Ballot(ranking=[{"C"}, {"B"}, {"A"}]), + ] + test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) + + # count the number of wins over a set of trials + winner_counts = {c: 0 for c in candidates} + trials = 2000 + for t in range(trials): + election = RandomDictator(test_profile, 1) + winner = list(election.get_elected()[0])[0] + winner_counts[winner] += 1 + + # check to make sure that the fraction of wins matches the true probability + assert np.allclose(3 / 5, winner_counts["A"] / trials, atol=1e-2) diff --git a/tests/kev_test_elections.py b/tests/kev_test_elections.py deleted file mode 100644 index f5b0af4..0000000 --- a/tests/kev_test_elections.py +++ /dev/null @@ -1,285 +0,0 @@ -from fractions import Fraction -from pathlib import Path -import pytest -import random -import numpy as np - -from votekit.ballot import Ballot -from votekit.cvr_loaders import load_scottish, load_csv # type:ignore -from votekit.elections.election_types import ( - STV, - SequentialRCV, - RandomDictator, - BoostedRandomDictator, - PluralityVeto, -) -from votekit.elections.transfers import fractional_transfer, random_transfer -from votekit.pref_profile import PreferenceProfile -from votekit.utils import ( - remove_cand, - compute_votes, -) - - -BASE_DIR = Path(__file__).resolve().parent -DATA_DIR = BASE_DIR / "data/csv/" - - -test_profile = load_csv(DATA_DIR / "test_election_A.csv") -mn_profile = load_csv("src/votekit/data/mn_2013_cast_vote_record.csv") - - -def test_droop_default_parameter(): - pp, seats, cand_list, cand_to_party, ward = load_scottish( - DATA_DIR / "scot_wardy_mc_ward.csv" - ) - - election = STV(pp, fractional_transfer, seats=seats) - - droop_quota = int((126 + 9 + 10 + 1) / (1 + 1)) + 1 - - assert election.threshold == droop_quota - - -def test_droop_inputed_parameter(): - pp, seats, cand_list, cand_to_party, ward = load_scottish( - DATA_DIR / "scot_wardy_mc_ward.csv" - ) - - election = STV(pp, fractional_transfer, seats=seats, quota="Droop") - - droop_quota = int((126 + 9 + 10 + 1) / (1 + 1)) + 1 - - assert election.threshold == droop_quota - - -def test_quota_misspelled_parameter(): - pp, seats, cand_list, cand_to_party, ward = load_scottish( - DATA_DIR / "scot_wardy_mc_ward.csv" - ) - - with pytest.raises(ValueError): - _ = STV(pp, fractional_transfer, seats=seats, quota="droops") - - -def test_hare_quota(): - pp, seats, cand_list, cand_to_party, ward = load_scottish( - DATA_DIR / "scot_wardy_mc_ward.csv" - ) - - election = STV(pp, fractional_transfer, seats=seats, quota="hare") - - hare_quota = int((126 + 9 + 10 + 1) / 1) - - assert election.threshold == hare_quota - - -def test_max_votes_toy(): - max_cand = "a" - cands = test_profile.get_candidates() - ballots = test_profile.get_ballots() - _, results = compute_votes(cands, ballots) - max_votes = [ - candidate - for candidate, votes in results.items() - if votes == max(results.values()) - ] - assert results[max_cand] == 6 - assert max_votes[0] == max_cand - - -def test_min_votes_mn(): - min_cand = "JOHN CHARLES WILSON" - cands = mn_profile.get_candidates() - ballots = mn_profile.get_ballots() - _, results = compute_votes(cands, ballots) - max_votes = [ - candidate - for candidate, votes in results.items() - if votes == min(results.values()) - ] - assert max_votes[0] == min_cand - - -def test_remove_cand_not_inplace(): - remove = "a" - ballots = test_profile.get_ballots() - new_ballots = remove_cand(remove, ballots) - assert ballots != new_ballots - - -def test_remove_fake_cand(): - remove = "z" - ballots = test_profile.get_ballots() - new_ballots = remove_cand(remove, ballots) - assert ballots == new_ballots - - -def test_remove_and_shift(): - remove = "a" - ballots = test_profile.get_ballots() - new_ballots = remove_cand(remove, ballots) - for ballot in new_ballots: - if len(ballot.ranking) == len(ballots[0].ranking): - assert len(ballot.ranking) == len(ballots[0].ranking) - - -def test_irv_winner_mn(): - irv = STV(mn_profile, fractional_transfer, 1, ballot_ties=False) - outcome = irv.run_election() - winner = "BETSY HODGES" - assert [{winner}] == outcome.elected - - -def test_stv_winner_mn(): - irv = STV(mn_profile, fractional_transfer, 3, ballot_ties=False) - outcome = irv.run_election() - winners = [{"BETSY HODGES"}, {"MARK ANDREW"}, {"DON SAMUELS"}] - assert winners == outcome.winners() - - -def test_runstep_seats_full_at_start(): - mock = STV(test_profile, fractional_transfer, 9, ballot_ties=False) - step = mock._profile - assert step == test_profile - - -def test_rand_transfer_func_mock_data(): - winner = "A" - ballots = [ - Ballot(ranking=({"A"}, {"C"}, {"B"}), weight=Fraction(2)), - Ballot(ranking=({"A"}, {"B"}, {"C"}), weight=Fraction(1)), - ] - votes = {"A": 3} - threshold = 1 - - ballots_after_transfer = random_transfer( - winner=winner, ballots=ballots, votes=votes, threshold=threshold - ) - - counts, _ = compute_votes(candidates=["B", "C"], ballots=ballots_after_transfer) - - assert counts[0].votes == Fraction(1) or counts[0].votes == Fraction(2) - - -def test_rand_transfer_assert(): - winner = "A" - ballots = [ - Ballot(ranking=({"A"}, {"C"}, {"B"}), weight=Fraction(1000)), - Ballot(ranking=({"A"}, {"B"}, {"C"}), weight=Fraction(1000)), - ] - votes = {"A": 2000} - threshold = 1000 - - ballots_after_transfer = random_transfer( - winner=winner, ballots=ballots, votes=votes, threshold=threshold - ) - counts, _ = compute_votes(candidates=["B", "C"], ballots=ballots_after_transfer) - - assert 400 < counts[0].votes < 600 - - -def test_toy_rcv(): - """ - example toy election taken from David McCune's code with known winners c and d - """ - known_winners = [{"c"}, {"d"}] - ballot_list = [ - Ballot(ranking=[{"a"}, {"b"}], weight=Fraction(1799)), - Ballot(ranking=[{"a"}, {"b"}, {"c"}, {"d"}], weight=Fraction(1801)), - Ballot(ranking=[{"a"}, {"c"}, {"d"}], weight=Fraction(100)), - Ballot(ranking=[{"b"}, {"c"}, {"a"}, {"d"}], weight=Fraction(901)), - Ballot(ranking=[{"b"}, {"d"}], weight=Fraction(900)), - Ballot(ranking=[{"c"}, {"b"}, {"d"}, {"a"}], weight=Fraction(498)), - Ballot(ranking=[{"c"}, {"d"}, {"a"}], weight=Fraction(2000)), - Ballot(ranking=[{"d"}, {"b"}], weight=Fraction(1400)), - Ballot(ranking=[{"d"}, {"c"}], weight=Fraction(601)), - ] - toy_pp = PreferenceProfile(ballots=ballot_list) - seq_RCV = SequentialRCV(profile=toy_pp, seats=2, ballot_ties=False) - toy_winners = seq_RCV.run_election().winners() - assert known_winners == toy_winners - - -def test_random_dictator(): - # set seed for more predictable results - random.seed(919717) - - # simple 3 candidate election - candidates = ["A", "B", "C"] - ballots = [ - Ballot(ranking=[{"A"}, {"B"}, {"C"}], weight=3), - Ballot(ranking=[{"B"}, {"A"}, {"C"}]), - Ballot(ranking=[{"C"}, {"B"}, {"A"}]), - ] - test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) - - # count the number of wins over a set of trials - winner_counts = {c: 0 for c in candidates} - trials = 10000 - for t in range(trials): - election = RandomDictator(test_profile, 1) - election.run_election() - winner = list(election.state.winners()[0])[0] - winner_counts[winner] += 1 - - # check to make sure that the fraction of wins matches the true probability - assert np.allclose(3 / 5, winner_counts["A"] / trials, atol=1e-2) - - -def test_boosted_random_dictator(): - # set seed for more predictable results - random.seed(919717) - - # simple 3 candidate election - candidates = ["A", "B", "C"] - ballots = [ - Ballot(ranking=[{"A"}, {"B"}, {"C"}], weight=3), - Ballot(ranking=[{"B"}, {"A"}, {"C"}]), - Ballot(ranking=[{"C"}, {"B"}, {"A"}]), - ] - test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) - - # count the number of wins over a set of trials - winner_counts = {c: 0 for c in candidates} - trials = 10000 - for t in range(trials): - election = BoostedRandomDictator(test_profile, 1) - election.run_election() - winner = list(election.state.winners()[0])[0] - winner_counts[winner] += 1 - - # check to make sure that the fraction of wins matches the true probability - assert np.allclose( - 1 / 2 * 3 / 5 + 1 / 2 * 9 / 11, winner_counts["A"] / trials, atol=1e-2 - ) - - -def test_plurality_veto(): - random.seed(919717) - - # simple 3 candidate election - candidates = ["A", "B", "C"] - # With every possible permutation of candidates, we should - # see that each candidate wins with probability 1/3 - ballots = [ - Ballot(ranking=[{"A"}, {"B"}, {"C"}]), - Ballot(ranking=[{"A"}, {"C"}, {"B"}]), - Ballot(ranking=[{"B"}, {"A"}, {"C"}]), - Ballot(ranking=[{"B"}, {"C"}, {"A"}]), - Ballot(ranking=[{"C"}, {"B"}, {"A"}]), - Ballot(ranking=[{"C"}, {"A"}, {"B"}]), - ] - test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) - - # count the number of wins over a set of trials - winner_counts = {c: 0 for c in candidates} - trials = 10000 - for t in range(trials): - election = PluralityVeto(test_profile, 1) - election.run_election() - winner = list(election.state.winners()[0])[0] - winner_counts[winner] += 1 - - # check to make sure that the fraction of wins matches the true probability - assert np.allclose(1 / 3, winner_counts["A"] / trials, atol=1e-2) diff --git a/tests/test_bg_errors.py b/tests/test_bg_errors.py index 96e4196..9f69228 100644 --- a/tests/test_bg_errors.py +++ b/tests/test_bg_errors.py @@ -119,63 +119,37 @@ def test_spatial_generator(): def bad_dist(x, y, z): return x + y + z - with pytest.raises( - ValueError, - match="No parameters were given for " "the input voter distribution.", - ): - Spatial( - candidates=candidates, - voter_dist=np.random.normal, - voter_params=None, - candidate_dist=np.random.normal, - candidate_params=normal_params, - ) - - with pytest.raises( - ValueError, - match="No parameters were given for " "the input candidate distribution.", - ): - Spatial( - candidates=candidates, - voter_dist=np.random.normal, - voter_params=normal_params, - candidate_dist=np.random.normal, - candidate_params=None, - ) - - with pytest.raises( - TypeError, match="Invalid parameters for the voter distribution." - ): + with pytest.raises(TypeError, match="Invalid kwargs for the voter distribution."): Spatial( candidates=candidates, voter_dist=np.random.normal, - voter_params=uniform_params, + voter_dist_kwargs=uniform_params, candidate_dist=np.random.normal, - candidate_params=normal_params, + candidate_dist_kwargs=normal_params, ) with pytest.raises( - TypeError, match="Invalid parameters for the candidate distribution." + TypeError, match="Invalid kwargs for the candidate distribution." ): Spatial( candidates=candidates, voter_dist=np.random.normal, - voter_params=normal_params, + voter_dist_kwargs=normal_params, candidate_dist=np.random.normal, - candidate_params=uniform_params, + candidate_dist_kwargs=uniform_params, ) with pytest.raises( - ValueError, + TypeError, match="Distance function is invalid or " "incompatible with voter/candidate distributions.", ): Spatial( candidates=candidates, voter_dist=np.random.normal, - voter_params=normal_params, + voter_dist_kwargs=normal_params, candidate_dist=np.random.normal, - candidate_params=normal_params, + candidate_dist_kwargs=normal_params, distance=bad_dist, ) @@ -188,63 +162,37 @@ def test_clustered_spatial_generator(): def bad_dist(x, y, z): return x + y + z - with pytest.raises( - ValueError, - match="No parameters were given for " "the input voter distribution.", - ): - ClusteredSpatial( - candidates=candidates, - voter_dist=np.random.logistic, - voter_params=None, - candidate_dist=np.random.normal, - candidate_params=normal_params, - ) - - with pytest.raises( - ValueError, - match="No parameters were given for " "the input candidate distribution.", - ): - ClusteredSpatial( - candidates=candidates, - voter_dist=np.random.normal, - voter_params=normal_params, - candidate_dist=np.random.normal, - candidate_params=None, - ) - - with pytest.raises( - TypeError, match="Invalid parameters for the voter distribution." - ): + with pytest.raises(TypeError, match="Invalid kwargs for the voter distribution."): ClusteredSpatial( candidates=candidates, voter_dist=np.random.normal, - voter_params=uniform_params, + voter_dist_kwargs=uniform_params, candidate_dist=np.random.normal, - candidate_params=normal_params, + candidate_dist_kwargs=normal_params, ) with pytest.raises( - TypeError, match="Invalid parameters for the candidate distribution." + TypeError, match="Invalid kwargs for the candidate distribution." ): ClusteredSpatial( candidates=candidates, voter_dist=np.random.normal, - voter_params=normal_params, + voter_dist_kwargs=normal_params, candidate_dist=np.random.normal, - candidate_params=uniform_params, + candidate_dist_kwargs=uniform_params, ) with pytest.raises( - ValueError, + TypeError, match="Distance function is invalid or " "incompatible with voter/candidate distributions.", ): ClusteredSpatial( candidates=candidates, voter_dist=np.random.normal, - voter_params=normal_params, + voter_dist_kwargs=normal_params, candidate_dist=np.random.normal, - candidate_params=normal_params, + candidate_dist_kwargs=normal_params, distance=bad_dist, ) @@ -252,7 +200,7 @@ def bad_dist(x, y, z): ClusteredSpatial( candidates=candidates, voter_dist=np.random.uniform, - voter_params=normal_params, + voter_dist_kwargs=normal_params, candidate_dist=np.random.normal, - candidate_params=normal_params, + candidate_dist_kwargs=normal_params, ) From f6866c4fd74fab0f4a03572317fbb570ceb31960 Mon Sep 17 00:00:00 2001 From: Kevin Quinn <54643158+kevin-q2@users.noreply.github.com> Date: Fri, 9 Aug 2024 15:48:52 -0400 Subject: [PATCH 10/16] Update plurality_veto.py Adjusting for exhausted ballots. --- .../election_types/ranking/plurality_veto.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/src/votekit/elections/election_types/ranking/plurality_veto.py b/src/votekit/elections/election_types/ranking/plurality_veto.py index 930f392..b06e41b 100644 --- a/src/votekit/elections/election_types/ranking/plurality_veto.py +++ b/src/votekit/elections/election_types/ranking/plurality_veto.py @@ -131,7 +131,7 @@ def _run_step( c for c, score in prev_state.scores.items() if score <= 0 ] - for i, ballot_index in enumerate(self.random_order): + for rand_index, ballot_index in enumerate(self.random_order): # TODO problem, if ballot disappears after all candidates are removed, # possible that an index will appear that is beyond the current list # of ballots @@ -157,7 +157,16 @@ def _run_step( # Update the randomized order so that # we can continue where we left off next round - self.random_order = self.random_order[i + 1 :] + self.random_order = (self.random_order[rand_index + 1 :] + + self.random_order[: rand_index + 1]) + + # Adjust for exhausted ballots. + for i,ballot_index in enumerate(self.random_order): + ballot = ballots[ballot_index] + ballot_cands = [list(_)[0] for _ in ballot.ranking] + if set(ballot_cands) == set(eliminated_cands): + self.random_order = [r - 1 if r > ballot_index else r + for r in self.random_order if r != ballot_index] new_profile = remove_cand(eliminated_cands, profile) From 879884e3b129367d2d87a7e87571c67f194347ef Mon Sep 17 00:00:00 2001 From: Kevin Quinn Date: Fri, 9 Aug 2024 18:28:40 -0400 Subject: [PATCH 11/16] fixed plurality veto --- .../election_types/ranking/plurality_veto.py | 80 +++++++++++-------- 1 file changed, 48 insertions(+), 32 deletions(-) diff --git a/src/votekit/elections/election_types/ranking/plurality_veto.py b/src/votekit/elections/election_types/ranking/plurality_veto.py index b06e41b..796dcb1 100644 --- a/src/votekit/elections/election_types/ranking/plurality_veto.py +++ b/src/votekit/elections/election_types/ranking/plurality_veto.py @@ -58,8 +58,13 @@ def __init__( ballots=tuple(new_ballots), candidates=profile.candidates ) + self.ballot_list = profile.ballots self.random_order = list(range(int(profile.num_ballots))) np.random.shuffle(self.random_order) + # self.ballot_eliminated = np.zeros(int(profile.num_ballots), dtype = bool) + self.preference_index = [len(ballot.ranking) - 1 for ballot in profile.ballots + if ballot.ranking is not None] + self.eliminated_dict = {c: False for c in profile.candidates} super().__init__(profile, score_function=first_place_votes) @@ -102,10 +107,9 @@ def _run_step( PreferenceProfile: The profile of ballots after the round is completed. """ - candidates = profile.candidates - ballots = profile.ballots + remaining_count = sum(1 for _ in self.eliminated_dict.values() if not _) - if len(candidates) == self.m: + if remaining_count == self.m: # move all to elected, this is the last round elected = prev_state.remaining new_profile = PreferenceProfile() @@ -135,38 +139,50 @@ def _run_step( # TODO problem, if ballot disappears after all candidates are removed, # possible that an index will appear that is beyond the current list # of ballots - ballot = ballots[ballot_index] - - if ballot.ranking: - # do with tiebreak methods - if len(ballot.ranking[-1]) > 1: - if self.tiebreak: - tiebroken_ranking = tiebreak_set( - ballot.ranking[-1], profile, self.tiebreak - ) - tiebreaks = {ballot.ranking[-1]: tiebroken_ranking} - else: - tiebroken_ranking = (ballot.ranking[-1],) - - least_preferred = list(tiebroken_ranking[-1])[0] - new_scores[least_preferred] -= Fraction(1) - - if new_scores[least_preferred] <= 0: - eliminated_cands.append(least_preferred) - break + if not self.preference_index[ballot_index] < 0: + ballot = self.ballot_list[ballot_index] + last_place = self.preference_index[ballot_index] + + if ballot.ranking: + # do with tiebreak methods + if len(ballot.ranking[last_place]) > 1: + if self.tiebreak: + tiebroken_ranking = tiebreak_set( + ballot.ranking[last_place], profile, self.tiebreak + ) + tiebreaks = {ballot.ranking[last_place]: tiebroken_ranking} + else: + tiebroken_ranking = (ballot.ranking[last_place],) + + least_preferred = list(tiebroken_ranking[-1])[0] + new_scores[least_preferred] -= Fraction(1) + + if new_scores[least_preferred] <= 0: + eliminated_cands.append(least_preferred) + break # Update the randomized order so that # we can continue where we left off next round - self.random_order = (self.random_order[rand_index + 1 :] - + self.random_order[: rand_index + 1]) - - # Adjust for exhausted ballots. - for i,ballot_index in enumerate(self.random_order): - ballot = ballots[ballot_index] - ballot_cands = [list(_)[0] for _ in ballot.ranking] - if set(ballot_cands) == set(eliminated_cands): - self.random_order = [r - 1 if r > ballot_index else r - for r in self.random_order if r != ballot_index] + self.random_order = ( + self.random_order[rand_index + 1 :] + + self.random_order[: rand_index + 1] + ) + + for c in eliminated_cands: + self.eliminated_dict[c] = True + + # Adjust voter's least preferred indices + for i, ballot_index in enumerate(self.random_order): + ballot = self.ballot_list[ballot_index] + last_place = self.preference_index[ballot_index] + if ballot.ranking is not None: + while ( + self.eliminated_dict[list(ballot.ranking[last_place])[0]] + and last_place > 0 + ): + last_place -= 1 + + self.preference_index[ballot_index] = last_place new_profile = remove_cand(eliminated_cands, profile) From 8e205b9c9c7e603c49be52cb296e4973e0912b49 Mon Sep 17 00:00:00 2001 From: Kevin Quinn Date: Fri, 9 Aug 2024 18:33:36 -0400 Subject: [PATCH 12/16] plurality veto tests --- .gitignore | 3 ++- .../election_types/ranking/test_plurality_veto.py | 7 ++++--- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/.gitignore b/.gitignore index 87102f2..3e98771 100644 --- a/.gitignore +++ b/.gitignore @@ -10,4 +10,5 @@ extra_data/ .venv .docs_venv docs/_build -.dev \ No newline at end of file +.dev +vote2 \ No newline at end of file diff --git a/tests/elections/election_types/ranking/test_plurality_veto.py b/tests/elections/election_types/ranking/test_plurality_veto.py index ff937e0..bb8665f 100644 --- a/tests/elections/election_types/ranking/test_plurality_veto.py +++ b/tests/elections/election_types/ranking/test_plurality_veto.py @@ -24,11 +24,12 @@ def test_plurality_veto(): # count the number of wins over a set of trials winner_counts = {c: 0 for c in candidates} - trials = 10000 + trials = 2000 for t in range(trials): election = PluralityVeto(test_profile, 1) - election.run_election() - winner = list(election.state.winners()[0])[0] + # election.run_election() + winner = list(election.get_elected()[0])[0] + # winner = list(election.state.winners()[0])[0] winner_counts[winner] += 1 # check to make sure that the fraction of wins matches the true probability From aac570cbc1e652b17e7bd78412b108c9e91cda0d Mon Sep 17 00:00:00 2001 From: peterrrock2 <27579114+peterrrock2@users.noreply.github.com> Date: Wed, 14 Aug 2024 15:41:44 -0600 Subject: [PATCH 13/16] Fix plurality veto and add more comprehensive tests --- .../elections/election_types/ranking/borda.py | 2 +- .../election_types/ranking/plurality_veto.py | 92 +++++++++---- .../elections/election_types/scores/rating.py | 2 +- src/votekit/utils.py | 60 +++++++-- tests/conftest.py | 66 +++++++++ .../ranking/test_plurality_veto.py | 126 ++++++++++++++++-- 6 files changed, 301 insertions(+), 47 deletions(-) create mode 100644 tests/conftest.py diff --git a/src/votekit/elections/election_types/ranking/borda.py b/src/votekit/elections/election_types/ranking/borda.py index a8a804b..aa102f1 100644 --- a/src/votekit/elections/election_types/ranking/borda.py +++ b/src/votekit/elections/election_types/ranking/borda.py @@ -13,7 +13,7 @@ class Borda(RankingElection): - """ + r""" Borda election. Positional voting system that assigns a decreasing number of points to candidates based on their ordering. The conventional score vector is :math:`(n, n-1, \dots, 1)` where :math:`n` is the number of candidates. Candidates with the highest scores are elected. diff --git a/src/votekit/elections/election_types/ranking/plurality_veto.py b/src/votekit/elections/election_types/ranking/plurality_veto.py index 796dcb1..1771626 100644 --- a/src/votekit/elections/election_types/ranking/plurality_veto.py +++ b/src/votekit/elections/election_types/ranking/plurality_veto.py @@ -27,12 +27,44 @@ class PluralityVeto(RankingElection): tiebreak (str, optional): Tiebreak method to use. Options are None, 'random', and 'borda'. Defaults to None, in which case a tie raises a ValueError. - + Attributes: + m (int): The number of seats to be filled in the election. + tiebreak (Optional[str]): The tiebreak method selected for the election. Could be None, + 'random', or 'borda'. + ballot_list (List[Ballot]): A list of Ballot instances representing the decondensed ballots + where each ballot has a weight of 1. + random_order (List[int]): A list of indices representing the randomized order in which + voters' preferences are processed. + preference_index (List[int]): A list of integers where each entry corresponds to the + index of the least preferred candidate for each ballot. + eliminated_dict (Dict[str, bool]): A dictionary mapping each candidate to a boolean value + indicating whether the candidate has been eliminated. + + Raises: + ValueError: If ``m`` is not positive or if it exceeds the number of candidates. """ def __init__( self, profile: PreferenceProfile, m: int, tiebreak: Optional[str] = None ): + """ + Initializes the Plurality Veto election class. + + This constructor sets up the initial state of the election, including + validating the profile, decondensing ballots (necessary for the running the steps of the + election), and preparing other necessary data structures. + + Args: + profile (PreferenceProfile): The preference profile to be used in the election. + m (int): The number of seats to be filled in the election. + tiebreak (Optional[str]): The method used to resolve ties. Defaults to None. + + Raises: + ValueError: If ``m`` is less than or equal to 0, or if ``m`` exceeds the number of + candidates in the profile. + AttributeError: If there are any ballots with ties and no tiebreak method is specified. + TypeError: If the profile contains invalid ballots. + """ self._pv_validate_profile(profile) if m <= 0: @@ -45,6 +77,13 @@ def __init__( self.m = m self.tiebreak = tiebreak + if self.tiebreak is None: + for ballot in profile.ballots: + if any(len(s) > 1 for s in ballot.ranking): + raise AttributeError( + "Found Ballots with ties but no tiebreak method was specified." + ) + # Decondense ballots ballots = profile.ballots new_ballots = [Ballot() for _ in range(int(profile.total_ballot_wt))] @@ -61,9 +100,11 @@ def __init__( self.ballot_list = profile.ballots self.random_order = list(range(int(profile.num_ballots))) np.random.shuffle(self.random_order) - # self.ballot_eliminated = np.zeros(int(profile.num_ballots), dtype = bool) - self.preference_index = [len(ballot.ranking) - 1 for ballot in profile.ballots - if ballot.ranking is not None] + self.preference_index = [ + len(ballot.ranking) - 1 if ballot.ranking else -1 + for ballot in self.ballot_list + ] + self.eliminated_dict = {c: False for c in profile.candidates} super().__init__(profile, score_function=first_place_votes) @@ -107,7 +148,7 @@ def _run_step( PreferenceProfile: The profile of ballots after the round is completed. """ - remaining_count = sum(1 for _ in self.eliminated_dict.values() if not _) + remaining_count = len(self.eliminated_dict) - sum(self.eliminated_dict.values()) if remaining_count == self.m: # move all to elected, this is the last round @@ -136,15 +177,11 @@ def _run_step( ] for rand_index, ballot_index in enumerate(self.random_order): - # TODO problem, if ballot disappears after all candidates are removed, - # possible that an index will appear that is beyond the current list - # of ballots if not self.preference_index[ballot_index] < 0: ballot = self.ballot_list[ballot_index] last_place = self.preference_index[ballot_index] if ballot.ranking: - # do with tiebreak methods if len(ballot.ranking[last_place]) > 1: if self.tiebreak: tiebroken_ranking = tiebreak_set( @@ -161,8 +198,8 @@ def _run_step( eliminated_cands.append(least_preferred) break - # Update the randomized order so that - # we can continue where we left off next round + # Circularly shift the randomized order array so that + # we can continue where we left off in the next round self.random_order = ( self.random_order[rand_index + 1 :] + self.random_order[: rand_index + 1] @@ -171,25 +208,31 @@ def _run_step( for c in eliminated_cands: self.eliminated_dict[c] = True - # Adjust voter's least preferred indices - for i, ballot_index in enumerate(self.random_order): - ballot = self.ballot_list[ballot_index] - last_place = self.preference_index[ballot_index] - if ballot.ranking is not None: - while ( - self.eliminated_dict[list(ballot.ranking[last_place])[0]] - and last_place > 0 - ): - last_place -= 1 + new_profile = remove_cand( + eliminated_cands, + profile, + condense=False, + leave_zero_weight_ballots=True, + ) - self.preference_index[ballot_index] = last_place + self.ballot_list = new_profile.ballots - new_profile = remove_cand(eliminated_cands, profile) + self.preference_index = [ + len(ballot.ranking) - 1 if ballot.ranking else -1 + for ballot in self.ballot_list + ] if store_states: eliminated = (frozenset(eliminated_cands),) + + score_ballots = [ + ballot for ballot in new_profile.ballots if ballot.ranking + ] + score_profile = PreferenceProfile(ballots=score_ballots) + if self.score_function: - scores = self.score_function(new_profile) + scores = self.score_function(score_profile) + remaining = score_dict_to_ranking(scores) new_state = ElectionState( round_number=prev_state.round_number + 1, @@ -200,5 +243,4 @@ def _run_step( ) self.election_states.append(new_state) - return new_profile diff --git a/src/votekit/elections/election_types/scores/rating.py b/src/votekit/elections/election_types/scores/rating.py index 363980a..ee6d361 100644 --- a/src/votekit/elections/election_types/scores/rating.py +++ b/src/votekit/elections/election_types/scores/rating.py @@ -157,7 +157,7 @@ def __init__( class Limited(GeneralRating): - """ + r""" Voters can score each candidate, but have a total budget of :math:`k\le m` points. Winners are those with highest total score. diff --git a/src/votekit/utils.py b/src/votekit/utils.py index c0c4c7a..9911f9c 100644 --- a/src/votekit/utils.py +++ b/src/votekit/utils.py @@ -59,6 +59,8 @@ def ballots_by_first_cand(profile: PreferenceProfile) -> dict[str, list[Ballot]] def remove_cand( removed: Union[str, list], profile_or_ballots: COB, + condense: bool = True, + leave_zero_weight_ballots: bool = False, ) -> COB: """ Removes specified candidate(s) from profile, ballot, or list of ballots. When a candidate is @@ -69,6 +71,9 @@ def remove_cand( removed (Union[str, list]): Candidate or list of candidates to be removed. profile_or_ballots (Union[PreferenceProfile, tuple[Ballot,...], Ballot]): Collection of ballots to remove candidates from. + condense (bool, optional): Whether or not to return a condensed profile. Defaults to True. + leave_zero_weight_ballots (bool, optional): Whether or not to leave ballots with zero + weight in the PreferenceProfile. Defaults to False. Returns: Union[PreferenceProfile, tuple[Ballot,...],Ballot]: @@ -79,7 +84,7 @@ def remove_cand( # map to tuple of ballots if isinstance(profile_or_ballots, PreferenceProfile): - ballots = profile_or_ballots.condense_ballots().ballots + ballots = profile_or_ballots.ballots elif isinstance(profile_or_ballots, Ballot): ballots = (profile_or_ballots,) else: @@ -121,26 +126,57 @@ def remove_cand( # return matching input data type if isinstance(profile_or_ballots, PreferenceProfile): - # easiest way to condense ballots clean_profile = PreferenceProfile( ballots=tuple([b for b in scrubbed_ballots if b.weight > 0]), candidates=tuple( [c for c in profile_or_ballots.candidates if c not in removed] ), - ).condense_ballots() + ) + + if leave_zero_weight_ballots: + clean_profile = PreferenceProfile( + ballots=tuple(scrubbed_ballots), + candidates=tuple( + [c for c in profile_or_ballots.candidates if c not in removed] + ), + ) + + if condense: + clean_profile = clean_profile.condense_ballots() return cast(COB, clean_profile) + elif isinstance(profile_or_ballots, Ballot): - # easiest way to condense ballots - clean_profile = PreferenceProfile( - ballots=tuple([b for b in scrubbed_ballots if b.weight > 0]), - ).condense_ballots() + clean_profile = None + + if leave_zero_weight_ballots: + clean_profile = PreferenceProfile( + ballots=tuple(scrubbed_ballots), + ) + else: + clean_profile = PreferenceProfile( + ballots=tuple([b for b in scrubbed_ballots if b.weight > 0]), + ) + + if condense: + clean_profile = clean_profile.condense_ballots() + return cast(COB, clean_profile.ballots[0]) else: - # easiest way to condense ballots - clean_profile = PreferenceProfile( - ballots=tuple([b for b in scrubbed_ballots if b.weight > 0]), - ).condense_ballots() + clean_profile = None + + if leave_zero_weight_ballots: + clean_profile = PreferenceProfile( + ballots=tuple(scrubbed_ballots), + ) + else: + clean_profile = PreferenceProfile( + ballots=tuple([b for b in scrubbed_ballots if b.weight > 0]), + ) + + if condense: + clean_profile = clean_profile.condense_ballots() + return cast(COB, clean_profile.ballots) @@ -320,7 +356,7 @@ def borda_scores( profile: PreferenceProfile, to_float: bool = False, ) -> Union[dict[str, Fraction], dict[str, float]]: - """ + r""" Calculates Borda scores for a ``PreferenceProfile``. The Borda vector is :math:`(n,n-1,\dots,1)` where :math:`n` is the number of candidates. diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..c4f8e1a --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,66 @@ +import pytest +from votekit import Ballot +import itertools + + +print("conftest.py is being imported") + + +def partitions_with_permutations_of_size(set_, subset_size): + """ + Generate all partitions of subsets of a given size with all permutations of each partition. + + Args: + set_ (set): The input set to partition and permute. + subset_size (int): The size of the subsets for which to generate partitions. + + Returns: + List[List[List]]: A list of all partitions with permutations of the specified subset size. + """ + + def partitions(set_): + """Generate all partitions of a set.""" + if not set_: + return [[]] + result = [] + for i in range(1, len(set_) + 1): + for combination in itertools.combinations(set_, i): + rest = set_ - set(combination) + for subpartition in partitions(rest): + result.append([frozenset(combination)] + subpartition) + return result + + # Generate all subsets of the desired size + subsets_of_size = list(itertools.combinations(set_, subset_size)) + + all_partitions_with_permutations = [] + + for subset in subsets_of_size: + subset_set = set(subset) + all_partitions = partitions(subset_set) + for partition in all_partitions: + for perm in itertools.permutations(partition): + all_partitions_with_permutations.append(tuple(perm)) + + return all_partitions_with_permutations + + +@pytest.fixture +def all_possible_ranked_ballots(): + + def inner(cand_set): + if len(cand_set) > 5: + raise ValueError("Can only generate ballots for sets of size 5 or less.") + + results = [] + for i in range(1, len(cand_set) + 1): + full_subsets = { + x: 0 for x in partitions_with_permutations_of_size(cand_set, i) + } + + results += list(list(x) for x in full_subsets) + + results = [Ballot(ranking=[set(x) for x in lst]) for lst in results] + return results + + return inner diff --git a/tests/elections/election_types/ranking/test_plurality_veto.py b/tests/elections/election_types/ranking/test_plurality_veto.py index bb8665f..efcfaca 100644 --- a/tests/elections/election_types/ranking/test_plurality_veto.py +++ b/tests/elections/election_types/ranking/test_plurality_veto.py @@ -2,10 +2,21 @@ from votekit.elections import PluralityVeto import random import numpy as np +import itertools +from joblib import Parallel, delayed + + +# TODO add tests for multiple winners + + +def run_election_once(test_profile): + """Run one election and return the winner.""" + election = PluralityVeto(test_profile, 1) + return list(election.get_elected()[0])[0] # TODO make tests in line with other election types -def test_plurality_veto(): +def test_plurality_veto_simple_3_candidates(): random.seed(919717) # simple 3 candidate election @@ -25,12 +36,111 @@ def test_plurality_veto(): # count the number of wins over a set of trials winner_counts = {c: 0 for c in candidates} trials = 2000 - for t in range(trials): - election = PluralityVeto(test_profile, 1) - # election.run_election() - winner = list(election.get_elected()[0])[0] - # winner = list(election.state.winners()[0])[0] - winner_counts[winner] += 1 + + # Parallel execution + n_jobs = -1 # Use all available cores + results = Parallel(n_jobs=n_jobs)( + delayed(run_election_once)(test_profile) for _ in range(trials) + ) + + winner_counts = {c: results.count(c) for c in candidates} # check to make sure that the fraction of wins matches the true probability - assert np.allclose(1 / 3, winner_counts["A"] / trials, atol=1e-2) + assert np.allclose(1 / 3, winner_counts["A"] / trials, atol=5e-2) + assert np.allclose(1 / 3, winner_counts["B"] / trials, atol=5e-2) + assert np.allclose(1 / 3, winner_counts["C"] / trials, atol=5e-2) + + +def test_plurality_veto_4_candidates_without_ties(): + random.seed(919717) + + candidates = ["A", "B", "C", "D"] + + full_power = list( + list( + list(itertools.permutations(x)) + for x in itertools.combinations(candidates, r) + ) + for r in range(1, len(candidates) + 1) + ) + powerset = [x for sublist in full_power for item in sublist for x in item] + + ballots = list(map(lambda x: Ballot(ranking=list(set(y) for y in x)), powerset)) + + test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) + + trials = 5000 + + # Parallel execution + n_jobs = -1 # Use all available cores + results = Parallel(n_jobs=n_jobs)( + delayed(run_election_once)(test_profile) for _ in range(trials) + ) + + winner_counts = {c: results.count(c) for c in candidates} + + assert np.allclose(1 / 4, winner_counts["A"] / trials, atol=5e-2) + assert np.allclose(1 / 4, winner_counts["B"] / trials, atol=5e-2) + assert np.allclose(1 / 4, winner_counts["C"] / trials, atol=5e-2) + assert np.allclose(1 / 4, winner_counts["D"] / trials, atol=5e-2) + + +def run_election_once_with_ties(test_profile): + """Run one election and return the winner.""" + election = PluralityVeto(test_profile, 1, tiebreak="random") + return list(election.get_elected()[0])[0] + + +def test_plurality_veto_4_candidates_with_ties(): + random.seed(919717) + + candidates = ["A", "B", "C", "D"] + + powerset = list( + itertools.chain.from_iterable( + itertools.combinations(candidates, r) for r in range(1, len(candidates) + 1) + ) + ) + ballots = list(map(lambda x: Ballot(ranking=[x]), powerset)) + + test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) + + trials = 5000 + + # Parallel execution + n_jobs = -1 # Use all available cores + results = Parallel(n_jobs=n_jobs)( + delayed(run_election_once_with_ties)(test_profile) for _ in range(trials) + ) + + winner_counts = {c: results.count(c) for c in candidates} + + assert np.allclose(1 / 4, winner_counts["A"] / trials, atol=5e-2) + assert np.allclose(1 / 4, winner_counts["B"] / trials, atol=5e-2) + assert np.allclose(1 / 4, winner_counts["C"] / trials, atol=5e-2) + assert np.allclose(1 / 4, winner_counts["D"] / trials, atol=5e-2) + + +def test_plurality_veto_4_candidates_large_sample(all_possible_ranked_ballots): + random.seed(919717) + + candidates = ["A", "B", "C", "D"] + + ballots = all_possible_ranked_ballots(candidates) + + test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) + + trials = 5000 + + # Parallel execution + n_jobs = -1 # Use all available cores + results = Parallel(n_jobs=n_jobs)( + delayed(run_election_once_with_ties)(test_profile) for _ in range(trials) + ) + + winner_counts = {c: results.count(c) for c in candidates} + + assert np.allclose(1 / 4, winner_counts["A"] / trials, atol=5e-2) + assert np.allclose(1 / 4, winner_counts["B"] / trials, atol=5e-2) + assert np.allclose(1 / 4, winner_counts["C"] / trials, atol=5e-2) + assert np.allclose(1 / 4, winner_counts["D"] / trials, atol=5e-2) From 44768d38b689a58de838763f3e7b85bf043ce4e0 Mon Sep 17 00:00:00 2001 From: peterrrock2 <27579114+peterrrock2@users.noreply.github.com> Date: Wed, 14 Aug 2024 16:04:21 -0600 Subject: [PATCH 14/16] Add more tests for random_dictator --- .../ranking/test_random_dictator.py | 148 ++++++++++++++++-- 1 file changed, 138 insertions(+), 10 deletions(-) diff --git a/tests/elections/election_types/ranking/test_random_dictator.py b/tests/elections/election_types/ranking/test_random_dictator.py index 4236aaf..2e27467 100644 --- a/tests/elections/election_types/ranking/test_random_dictator.py +++ b/tests/elections/election_types/ranking/test_random_dictator.py @@ -2,14 +2,21 @@ from votekit.elections import RandomDictator import numpy as np import random +import itertools +from joblib import Parallel, delayed +from votekit.utils import first_place_votes -# TODO make tests in line with other election types -def test_random_dictator(): +def run_election_once(test_profile): + """Run one election and return the winner.""" + election = RandomDictator(test_profile, 1) + return list(election.get_elected()[0])[0] + + +def test_random_dictator_simple(): # set seed for more predictable results random.seed(919717) - # simple 3 candidate election candidates = ["A", "B", "C"] ballots = [ Ballot(ranking=[{"A"}, {"B"}, {"C"}], weight=3), @@ -18,13 +25,134 @@ def test_random_dictator(): ] test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) - # count the number of wins over a set of trials winner_counts = {c: 0 for c in candidates} - trials = 2000 - for t in range(trials): - election = RandomDictator(test_profile, 1) - winner = list(election.get_elected()[0])[0] - winner_counts[winner] += 1 + trials = 5000 + + # Parallel execution + n_jobs = -1 # Use all available cores + results = Parallel(n_jobs=n_jobs)( + delayed(run_election_once)(test_profile) for _ in range(trials) + ) + + winner_counts = {c: results.count(c) for c in candidates} # check to make sure that the fraction of wins matches the true probability - assert np.allclose(3 / 5, winner_counts["A"] / trials, atol=1e-2) + assert np.allclose(3 / 5, winner_counts["A"] / trials, atol=5e-2) + assert np.allclose(1 / 5, winner_counts["B"] / trials, atol=5e-2) + assert np.allclose(1 / 5, winner_counts["C"] / trials, atol=5e-2) + + +def test_random_dictator_4_candidates_without_ties(): + random.seed(919717) + + candidates = ["A", "B", "C", "D"] + + full_power = list( + list( + list(itertools.permutations(x)) + for x in itertools.combinations(candidates, r) + ) + for r in range(1, len(candidates) + 1) + ) + + powerset = [x for sublist in full_power for item in sublist for x in item] + + ballots = list( + map( + lambda x: Ballot( + ranking=list(set(y) for y in x), weight=3 if x[0] == "A" else 1 + ), + powerset, + ) + ) + + test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) + + fpv = first_place_votes(test_profile) + tot_fpv = sum(fpv.values()) + fpv = {c: v / tot_fpv for c, v in fpv.items()} + + trials = 5000 + + # Parallel execution + n_jobs = -1 # Use all available cores + results = Parallel(n_jobs=n_jobs)( + delayed(run_election_once)(test_profile) for _ in range(trials) + ) + + winner_counts = {c: results.count(c) for c in candidates} + + assert np.allclose(float(fpv["A"]), winner_counts["A"] / trials, atol=5e-2) + assert np.allclose(float(fpv["B"]), winner_counts["B"] / trials, atol=5e-2) + assert np.allclose(float(fpv["C"]), winner_counts["C"] / trials, atol=5e-2) + assert np.allclose(float(fpv["D"]), winner_counts["D"] / trials, atol=5e-2) + + +def test_random_dictator_4_candidates_with_ties(): + random.seed(919717) + + candidates = ["A", "B", "C", "D"] + + powerset = list( + itertools.chain.from_iterable( + itertools.combinations(candidates, r) for r in range(1, len(candidates) + 1) + ) + ) + + ballots = list( + map(lambda x: Ballot(ranking=[x], weight=3 if "A" in x[0] else 1), powerset) + ) + + test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) + + trials = 5000 + + fpv = first_place_votes(test_profile) + tot_fpv = sum(fpv.values()) + fpv = {c: v / tot_fpv for c, v in fpv.items()} + + # Parallel execution + n_jobs = -1 # Use all available cores + results = Parallel(n_jobs=n_jobs)( + delayed(run_election_once)(test_profile) for _ in range(trials) + ) + + winner_counts = {c: results.count(c) for c in candidates} + + assert np.allclose(float(fpv["A"]), winner_counts["A"] / trials, atol=5e-2) + assert np.allclose(float(fpv["B"]), winner_counts["B"] / trials, atol=5e-2) + assert np.allclose(float(fpv["C"]), winner_counts["C"] / trials, atol=5e-2) + assert np.allclose(float(fpv["D"]), winner_counts["D"] / trials, atol=5e-2) + + +def test_random_dictator_4_candidates_large_sample(all_possible_ranked_ballots): + random.seed(919717) + + candidates = ["A", "B", "C", "D"] + + ballots = all_possible_ranked_ballots(candidates) + + trials = 5000 + + for i, ballot in enumerate(ballots): + if "A" in ballot.ranking[0]: + ballots[i] = Ballot(ranking=ballot.ranking, weight=500) + + test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) + + fpv = first_place_votes(test_profile) + tot_fpv = sum(fpv.values()) + fpv = {c: v / tot_fpv for c, v in fpv.items()} + + # Parallel execution + n_jobs = -1 # Use all available cores + results = Parallel(n_jobs=n_jobs)( + delayed(run_election_once)(test_profile) for _ in range(trials) + ) + + winner_counts = {c: results.count(c) for c in candidates} + + assert np.allclose(float(fpv["A"]), winner_counts["A"] / trials, atol=5e-2) + assert np.allclose(float(fpv["B"]), winner_counts["B"] / trials, atol=5e-2) + assert np.allclose(float(fpv["C"]), winner_counts["C"] / trials, atol=5e-2) + assert np.allclose(float(fpv["D"]), winner_counts["D"] / trials, atol=5e-2) From bbd7c2cbedd2865fc29014906c36520ab9b335ea Mon Sep 17 00:00:00 2001 From: peterrrock2 <27579114+peterrrock2@users.noreply.github.com> Date: Wed, 14 Aug 2024 16:17:59 -0600 Subject: [PATCH 15/16] Add more tests for boosted_random_dictator --- .../ranking/test_boosted_random_dictator.py | 207 +++++++++++++++++- 1 file changed, 197 insertions(+), 10 deletions(-) diff --git a/tests/elections/election_types/ranking/test_boosted_random_dictator.py b/tests/elections/election_types/ranking/test_boosted_random_dictator.py index 77834f7..3d331c4 100644 --- a/tests/elections/election_types/ranking/test_boosted_random_dictator.py +++ b/tests/elections/election_types/ranking/test_boosted_random_dictator.py @@ -2,14 +2,20 @@ from votekit.elections import BoostedRandomDictator import random import numpy as np +from joblib import Parallel, delayed +import itertools +from votekit.utils import first_place_votes -# TODO make tests in line with other election types -def test_boosted_random_dictator(): - # set seed for more predictable results +def run_election_once(test_profile): + """Run one election and return the winner.""" + election = BoostedRandomDictator(test_profile, 1) + return list(election.get_elected()[0])[0] + + +def test_boosted_random_dictator_simple(): random.seed(919717) - # simple 3 candidate election candidates = ["A", "B", "C"] ballots = [ Ballot(ranking=[{"A"}, {"B"}, {"C"}], weight=3), @@ -18,15 +24,196 @@ def test_boosted_random_dictator(): ] test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) - # count the number of wins over a set of trials winner_counts = {c: 0 for c in candidates} - trials = 3000 - for t in range(trials): - election = BoostedRandomDictator(test_profile, 1) - winner = list(election.get_elected()[0])[0] - winner_counts[winner] += 1 + trials = 10000 + + # Parallel execution + n_jobs = -1 # Use all available cores + results = Parallel(n_jobs=n_jobs)( + delayed(run_election_once)(test_profile) for _ in range(trials) + ) + + winner_counts = {c: results.count(c) for c in candidates} # check to make sure that the fraction of wins matches the true probability assert np.allclose( 1 / 2 * 3 / 5 + 1 / 2 * 9 / 11, winner_counts["A"] / trials, atol=1e-2 ) + assert np.allclose( + 1 / 2 * 1 / 5 + 1 / 2 * 1 / 11, winner_counts["B"] / trials, atol=1e-2 + ) + assert np.allclose( + 1 / 2 * 1 / 5 + 1 / 2 * 1 / 11, winner_counts["C"] / trials, atol=1e-2 + ) + + +def test_boosted_random_dictator_4_candidates_without_ties(): + random.seed(919717) + + candidates = ["A", "B", "C", "D"] + + full_power = list( + list( + list(itertools.permutations(x)) + for x in itertools.combinations(candidates, r) + ) + for r in range(1, len(candidates) + 1) + ) + + powerset = [x for sublist in full_power for item in sublist for x in item] + + ballots = list( + map( + lambda x: Ballot( + ranking=list(set(y) for y in x), weight=3 if x[0] == "A" else 1 + ), + powerset, + ) + ) + + test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) + + fpv = first_place_votes(test_profile) + tot_fpv = sum(fpv.values()) + tot_fpv_sq = sum(x**2 for x in fpv.values()) + fpv_sq_dict = {c: v**2 / tot_fpv_sq for c, v in fpv.items()} + fpv = {c: v / tot_fpv for c, v in fpv.items()} + + trials = 10000 + + # Parallel execution + n_jobs = -1 # Use all available cores + results = Parallel(n_jobs=n_jobs)( + delayed(run_election_once)(test_profile) for _ in range(trials) + ) + + winner_counts = {c: results.count(c) for c in candidates} + + assert np.allclose( + 0.5 * float(fpv["A"]) + 0.5 * float(fpv_sq_dict["A"]), + winner_counts["A"] / trials, + atol=5e-2, + ) + assert np.allclose( + 0.5 * float(fpv["B"]) + 0.5 * float(fpv_sq_dict["B"]), + winner_counts["B"] / trials, + atol=5e-2, + ) + assert np.allclose( + 0.5 * float(fpv["C"]) + 0.5 * float(fpv_sq_dict["C"]), + winner_counts["C"] / trials, + atol=5e-2, + ) + assert np.allclose( + 0.5 * float(fpv["D"]) + 0.5 * float(fpv_sq_dict["D"]), + winner_counts["D"] / trials, + atol=5e-2, + ) + + +def test_boosted_random_dictator_4_candidates_with_ties(): + random.seed(919717) + + candidates = ["A", "B", "C", "D"] + + powerset = list( + itertools.chain.from_iterable( + itertools.combinations(candidates, r) for r in range(1, len(candidates) + 1) + ) + ) + + ballots = list( + map(lambda x: Ballot(ranking=[x], weight=3 if "A" in x[0] else 1), powerset) + ) + + test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) + + trials = 10000 + + fpv = first_place_votes(test_profile) + tot_fpv = sum(fpv.values()) + tot_fpv_sq = sum(x**2 for x in fpv.values()) + fpv_sq_dict = {c: v**2 / tot_fpv_sq for c, v in fpv.items()} + fpv = {c: v / tot_fpv for c, v in fpv.items()} + + # Parallel execution + n_jobs = -1 # Use all available cores + results = Parallel(n_jobs=n_jobs)( + delayed(run_election_once)(test_profile) for _ in range(trials) + ) + + winner_counts = {c: results.count(c) for c in candidates} + + assert np.allclose( + 0.5 * float(fpv["A"]) + 0.5 * float(fpv_sq_dict["A"]), + winner_counts["A"] / trials, + atol=5e-2, + ) + assert np.allclose( + 0.5 * float(fpv["B"]) + 0.5 * float(fpv_sq_dict["B"]), + winner_counts["B"] / trials, + atol=5e-2, + ) + assert np.allclose( + 0.5 * float(fpv["C"]) + 0.5 * float(fpv_sq_dict["C"]), + winner_counts["C"] / trials, + atol=5e-2, + ) + assert np.allclose( + 0.5 * float(fpv["D"]) + 0.5 * float(fpv_sq_dict["D"]), + winner_counts["D"] / trials, + atol=5e-2, + ) + + +def test_random_dictator_4_candidates_large_sample(all_possible_ranked_ballots): + random.seed(919717) + + candidates = ["A", "B", "C", "D"] + + ballots = all_possible_ranked_ballots(candidates) + + trials = 10000 + + for i, ballot in enumerate(ballots): + if "A" in ballot.ranking[0]: + ballots[i] = Ballot(ranking=ballot.ranking, weight=500) + + test_profile = PreferenceProfile(ballots=ballots, candidates=candidates) + + fpv = first_place_votes(test_profile) + tot_fpv = sum(fpv.values()) + tot_fpv_sq = sum(x**2 for x in fpv.values()) + fpv_sq_dict = {c: v**2 / tot_fpv_sq for c, v in fpv.items()} + fpv = {c: v / tot_fpv for c, v in fpv.items()} + + trials = 5000 + + # Parallel execution + n_jobs = -1 # Use all available cores + results = Parallel(n_jobs=n_jobs)( + delayed(run_election_once)(test_profile) for _ in range(trials) + ) + + winner_counts = {c: results.count(c) for c in candidates} + + assert np.allclose( + 0.5 * float(fpv["A"]) + 0.5 * float(fpv_sq_dict["A"]), + winner_counts["A"] / trials, + atol=5e-2, + ) + assert np.allclose( + 0.5 * float(fpv["B"]) + 0.5 * float(fpv_sq_dict["B"]), + winner_counts["B"] / trials, + atol=5e-2, + ) + assert np.allclose( + 0.5 * float(fpv["C"]) + 0.5 * float(fpv_sq_dict["C"]), + winner_counts["C"] / trials, + atol=5e-2, + ) + assert np.allclose( + 0.5 * float(fpv["D"]) + 0.5 * float(fpv_sq_dict["D"]), + winner_counts["D"] / trials, + atol=5e-2, + ) From 43bcfb6ed50b77dd05eb6fcf92c9265109036a1f Mon Sep 17 00:00:00 2001 From: Peter <27579114+peterrrock2@users.noreply.github.com> Date: Wed, 14 Aug 2024 18:37:51 -0600 Subject: [PATCH 16/16] Fix distributions for test_boosted_random_dictator --- .../ranking/test_boosted_random_dictator.py | 57 +++++++++---------- 1 file changed, 28 insertions(+), 29 deletions(-) diff --git a/tests/elections/election_types/ranking/test_boosted_random_dictator.py b/tests/elections/election_types/ranking/test_boosted_random_dictator.py index 3d331c4..a58c1bb 100644 --- a/tests/elections/election_types/ranking/test_boosted_random_dictator.py +++ b/tests/elections/election_types/ranking/test_boosted_random_dictator.py @@ -37,13 +37,13 @@ def test_boosted_random_dictator_simple(): # check to make sure that the fraction of wins matches the true probability assert np.allclose( - 1 / 2 * 3 / 5 + 1 / 2 * 9 / 11, winner_counts["A"] / trials, atol=1e-2 + 1 / 2 * 3 / 5 + 1 / 2 * 9 / 11, winner_counts["A"] / trials, atol=2e-2 ) assert np.allclose( - 1 / 2 * 1 / 5 + 1 / 2 * 1 / 11, winner_counts["B"] / trials, atol=1e-2 + 1 / 2 * 1 / 5 + 1 / 2 * 1 / 11, winner_counts["B"] / trials, atol=2e-2 ) assert np.allclose( - 1 / 2 * 1 / 5 + 1 / 2 * 1 / 11, winner_counts["C"] / trials, atol=1e-2 + 1 / 2 * 1 / 5 + 1 / 2 * 1 / 11, winner_counts["C"] / trials, atol=2e-2 ) @@ -90,24 +90,24 @@ def test_boosted_random_dictator_4_candidates_without_ties(): winner_counts = {c: results.count(c) for c in candidates} assert np.allclose( - 0.5 * float(fpv["A"]) + 0.5 * float(fpv_sq_dict["A"]), + 2 / 3 * float(fpv["A"]) + 1 / 3 * float(fpv_sq_dict["A"]), winner_counts["A"] / trials, - atol=5e-2, + atol=2e-2, ) assert np.allclose( - 0.5 * float(fpv["B"]) + 0.5 * float(fpv_sq_dict["B"]), + 2 / 3 * float(fpv["B"]) + 1 / 3 * float(fpv_sq_dict["B"]), winner_counts["B"] / trials, - atol=5e-2, + atol=2e-2, ) assert np.allclose( - 0.5 * float(fpv["C"]) + 0.5 * float(fpv_sq_dict["C"]), + 2 / 3 * float(fpv["C"]) + 1 / 3 * float(fpv_sq_dict["C"]), winner_counts["C"] / trials, - atol=5e-2, + atol=2e-2, ) assert np.allclose( - 0.5 * float(fpv["D"]) + 0.5 * float(fpv_sq_dict["D"]), + 2 / 3 * float(fpv["D"]) + 1 / 3 * float(fpv_sq_dict["D"]), winner_counts["D"] / trials, - atol=5e-2, + atol=2e-2, ) @@ -145,24 +145,24 @@ def test_boosted_random_dictator_4_candidates_with_ties(): winner_counts = {c: results.count(c) for c in candidates} assert np.allclose( - 0.5 * float(fpv["A"]) + 0.5 * float(fpv_sq_dict["A"]), + 2 / 3 * float(fpv["A"]) + 1 / 3 * float(fpv_sq_dict["A"]), winner_counts["A"] / trials, - atol=5e-2, + atol=2e-2, ) assert np.allclose( - 0.5 * float(fpv["B"]) + 0.5 * float(fpv_sq_dict["B"]), + 2 / 3 * float(fpv["B"]) + 1 / 3 * float(fpv_sq_dict["B"]), winner_counts["B"] / trials, - atol=5e-2, + atol=2e-2, ) assert np.allclose( - 0.5 * float(fpv["C"]) + 0.5 * float(fpv_sq_dict["C"]), + 2 / 3 * float(fpv["C"]) + 1 / 3 * float(fpv_sq_dict["C"]), winner_counts["C"] / trials, - atol=5e-2, + atol=2e-2, ) assert np.allclose( - 0.5 * float(fpv["D"]) + 0.5 * float(fpv_sq_dict["D"]), + 2 / 3 * float(fpv["D"]) + 1 / 3 * float(fpv_sq_dict["D"]), winner_counts["D"] / trials, - atol=5e-2, + atol=2e-2, ) @@ -187,8 +187,6 @@ def test_random_dictator_4_candidates_large_sample(all_possible_ranked_ballots): fpv_sq_dict = {c: v**2 / tot_fpv_sq for c, v in fpv.items()} fpv = {c: v / tot_fpv for c, v in fpv.items()} - trials = 5000 - # Parallel execution n_jobs = -1 # Use all available cores results = Parallel(n_jobs=n_jobs)( @@ -198,22 +196,23 @@ def test_random_dictator_4_candidates_large_sample(all_possible_ranked_ballots): winner_counts = {c: results.count(c) for c in candidates} assert np.allclose( - 0.5 * float(fpv["A"]) + 0.5 * float(fpv_sq_dict["A"]), + 2 / 3 * float(fpv["A"]) + 1 / 3 * float(fpv_sq_dict["A"]), winner_counts["A"] / trials, - atol=5e-2, + atol=2e-2, ) assert np.allclose( - 0.5 * float(fpv["B"]) + 0.5 * float(fpv_sq_dict["B"]), + 2 / 3 * float(fpv["B"]) + 1 / 3 * float(fpv_sq_dict["B"]), winner_counts["B"] / trials, - atol=5e-2, + atol=2e-2, ) assert np.allclose( - 0.5 * float(fpv["C"]) + 0.5 * float(fpv_sq_dict["C"]), + 2 / 3 * float(fpv["C"]) + 1 / 3 * float(fpv_sq_dict["C"]), winner_counts["C"] / trials, - atol=5e-2, + atol=2e-2, ) assert np.allclose( - 0.5 * float(fpv["D"]) + 0.5 * float(fpv_sq_dict["D"]), + 2 / 3 * float(fpv["D"]) + 1 / 3 * float(fpv_sq_dict["D"]), winner_counts["D"] / trials, - atol=5e-2, + atol=2e-2, ) +