def test1(self):
"""Test whether cnum limit is working"""
v = spatial.Voters(0)
v.add_random(20, 3)
c = spatial.Candidates(v, 0)
c.add_random(3).build()
print(c.data.pref)
e = spatial.Election(voters=v, candidates=c)
e.user_data(a=0, b=1)
print('running plurality')
e.run(etype='plurality')
print('running irv')
e.run(etype='irv')
e.run(etype='score')
# test dataframe construction
df = e.dataframe()
assert 'args.user.a' in df.keys()
assert 'args.user.b' in df.keys()
return df
def test_all():
numvoters = 50
num_candidates = 6
numwinners_list = [1, 3, 5]
for ii in range(50):
v = spatial.Voters(seed=ii,)
v.add_random(numvoters=numvoters, ndim=2, )
c = spatial.Candidates(voters=v, seed=0)
c.add_random(cnum=num_candidates, sdev=1.0)
e = spatial.Election(voters=v, candidates=c)
scores = e.ballotgen.get_honest_ballots(
etype=votesim.votemethods.SCORE
)
ranks = e.ballotgen.get_honest_ballots(
etype=votesim.votemethods.IRV
)
for etype in ranked_methods:
for numwinners in numwinners_list:
runner = eRunner(etype=etype,
ballots=ranks,
numwinners=numwinners)
winners = np.unique(runner.winners)
assert len(winners) == numwinners, etype
for etype in scored_methods:
for numwinners in numwinners_list:
runner = eRunner(etype=etype,
ballots=scores,
numwinners=numwinners)
winners = np.unique(runner.winners)
assert len(winners) == numwinners, etype
def test_case():
"""Test a case that failed during simple test benchmark.
After investigation it seems like this is a case where
all ballot scores are zero.
"""
seed = 0
numvoters = 101
cnum = 3
trial = 54
trialnum = 100
ndim = 2
stol = 0.25
base = 'linear'
name = 'test'
e = spatial.Election(None, None, seed=seed, name=name)
v = spatial.Voters(seed=seed, tol=stol, base=base)
v.add_random(numvoters, ndim=ndim)
cseed = seed * trialnum
c = spatial.Candidates(v, seed=trial + cseed)
c.add_random(cnum, sdev=1.5)
e.set_models(voters=v, candidates=c)
ballots = e.ballotgen.get_honest_ballots('maj_judge')
result = e.run('maj_judge')
assert np.all(result.ties == [0, 1, 2])
return
def model(x, methods):
"""Define election model here
Parameters
----------
x : tuple
Input arguments created from generator `case_args`
Returns
--------
out : Election
Election object.
"""
#time.sleep(1)
seed = x
cnum = 2
vnum = 10
ndim = 1
strategy = 'candidate'
trialnum = 2
e = spatial.Election(None, None, seed=seed, name=BENCHMARK_NAME)
v = spatial.Voters(seed=seed, strategy=strategy)
v.add_random(vnum, ndim=ndim)
for trial in range(trialnum):
c = spatial.Candidates(v, seed=trial)
c.add_random(cnum, sdev=1.5)
e.set_models(voters=v, candidates=c)
e.user_data(seed=seed)
for method in methods:
e.run(etype=method)
return e
def test_ranked_bury():
v = spatial.Voters(seed=0)
v.add(voter_pref)
c = spatial.Candidates(v)
c.add(candidate_pref)
strategy = {
'tactics': 'bury',
'subset': '',
'ratio': 1,
'underdog': None,
'frontrunnertype': 'eliminate'
}
s2 = spatial.Strategies(v).add(**strategy)
e2 = spatial.Election(voters=v, candidates=c, strategies=s2)
e2.run('ranked_pairs')
right = [[1, 2, 0], [1, 2, 0], [1, 2, 0], [1, 2, 0], [1, 2, 0], [1, 2, 0],
[1, 2, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0], [0, 0, 1], [0, 0, 1],
[0, 0, 1], [0, 0, 1], [0, 0, 1]]
right = votesim.votemethods.tools.rcv_reorder(right)
ballots = e2.result.ballots
ballots = votesim.votemethods.tools.rcv_reorder(ballots)
assert np.all(right == ballots)
return
def test():
v = spatial.Voters(0)
v.add_random(20, 1)
c = spatial.Candidates(v, 0)
c.add([[0], [1], [2]])
e = spatial.Election(voters=v, candidates=c)
e.run(etype='irv')
e.run(etype='plurality')
d2o = e.dataseries(0)
d3o = e.dataseries(1)
e2 = e.rerun(d2o)
e3 = e.rerun(d3o)
d2 = e2.dataseries()
d3 = e3.dataseries()
assert np.all(e.result.ballots == e3.result.ballots)
assert d2.equals(d2o)
assert d3.equals(d3o)
for key, value in d2.items():
print(key)
assert np.all(d2[key] == d2o[key])
def simple_model(name,
methods,
seed=0,
numvoters=100,
cnum=3,
trialnum=1,
ndim=1,
stol=1,
base='linear'):
"""Simple Election model """
e = spatial.Election(None, None, seed=seed, name=name)
v = spatial.Voters(seed=seed, tol=stol, base=base)
v.add_random(numvoters, ndim=ndim)
msg_base = 'seed=%s, numvoters=%s, cnum=%s, trial=%s, ndim=%s, stol=%s, base=%s'
cseed = seed * trialnum
for trial in range(trialnum):
logger.debug(msg_base, seed, numvoters, cnum, trial, ndim, stol, base)
c = spatial.Candidates(v, seed=trial + cseed)
c.add_random(cnum, sdev=1.5)
e.set_models(voters=v, candidates=c)
# Save parameters
e.user_data(num_voters=numvoters,
num_candidates=cnum,
num_dimensions=ndim,
voter_tolerance=stol)
for method in methods:
e.run(etype=method)
return e
def test_ranked_deep_bury():
"""Test ranked burial tactic.
Burial strategies
--------------------------
* For #0 voters, their ballots are unchanged as their least favorite is
already buried.
* For #1 voters, they decide to bury #2.
* For #2 voters, they decide to bury #1.
Outcomes
--------
Burial strategies backfires with #1 and #2 voters, allowing #0 to win.
"""
v = spatial.Voters(seed=0)
v.add(voter_pref)
c = spatial.Candidates(v)
c.add(candidate_pref)
# run honest election
e1 = spatial.Election(voters=v, candidates=c)
result1 = e1.run('ranked_pairs')
# Make sure condorcet winner was found
assert 1 in e1.result.winners
#run strategic election
strategy = {
'tactics': 'deep_bury',
'ratio': 1,
'underdog': None,
'subset': '',
'frontrunnertype': 'eliminate'
}
s2 = spatial.Strategies(v).add(**strategy)
e2 = spatial.Election(voters=v, candidates=c, strategies=s2)
e2.run('ranked_pairs', result=result1)
# Make sure the correct front runners were
tballots = e2.ballotgen.tacticalballots
tgroup = list(tballots.root._tactical_groups.values())[0]
front_runners = tgroup.front_runners
assert 1 in front_runners
assert 2 in front_runners
# Check that #0 is the winner
assert 0 in e2.result.winners
ballots = e2.result.ballots
ballots = votesim.votemethods.tools.rcv_reorder(ballots)
# Check the new tactical rankings
right = [[1, 2, 0], [1, 2, 0], [1, 2, 0], [1, 2, 0], [1, 2, 0], [1, 2, 0],
[1, 2, 0], [3, 1, 0], [3, 1, 0], [3, 1, 0], [3, 0, 1], [3, 0, 1],
[3, 0, 1], [3, 0, 1], [3, 0, 1]]
right = votesim.votemethods.tools.rcv_reorder(right)
assert np.all(right == ballots)
return
def test_plurality_bullet_preferred():
"""Test plurality bullet voting strategy.
Scenario attributes:
- 3 candidate race with 3 concentrated, coincident voter groups
>>> Candidates #0 #1 #2
>>> Preference locations = [-1, 0.5, 1]
>>> Number of voters = [ 7, 3, 5]
- If voters are honest, plurality candidate #0 should win with 7 votes
- If voters are strategic and consider only the top two candidates,
Candidate #1 supporters also lean towards #2 - therefore
candidate #2 should win with 3 + 5 = 8 votes.
"""
pref = [-1]*7 + [0.5]*3 + [1]*5
pref = np.array(pref)[:, None]
v = spatial.Voters(seed=0)
v.add(pref)
cpref = [-1, .5, 1]
cpref = np.array(cpref)[:, None]
c = spatial.Candidates(v)
c.add(cpref)
#####################################################################
# Run honest election
e1 = spatial.Election(voters=v, candidates=c)
e1.run('plurality')
tally1 = e1.result.runner.output['tally']
result1 = e1.result
#####################################################################
# Run strategic election
strategy1 = {'tactics' : 'bullet_preferred',
'ratio' : 1,
'subset' : 'underdog',
'underdog' : None,}
s = spatial.Strategies(v)
s.add(**strategy1)
e1.set_models(strategies=s)
e1.run('plurality', result=result1)
tally2 = e1.result.runner.output['tally']
result2 = e1.result
# Check honest vote tally
assert np.all(tally1 == np.array([7, 3, 5]))
# Check strategic vote tally
assert np.all(tally2 == np.array([7, 0, 8]))
# Check honest winner
assert 0 in result1.winners
# Check strategic winner
assert 2 in result2.winners
return
def test2():
"""Check that seed correctly re-set"""
v = spatial.Voters(seed=10)
v.add_random(20, 1)
c = spatial.Candidates(v, seed=5)
c.add_random(2)
e = spatial.Election(voters=v, candidates=c, seed=0)
e.run(etype='plurality')
s = e.dataseries()
v = spatial.Voters(seed=1)
v.add_random(5, 1)
c = spatial.Candidates(v, seed=5)
c.add_random(2)
e = spatial.Election(voters=v, candidates=c, seed=0)
er = e.rerun(s)
assert er.voters[0].seed == 10
assert er.voters[0]._pref.__len__() == 20
return
def test1(self):
v = spatial.Voters(0)
voters = np.array([[-2,-1,0,1,2,]]).T
v.add(voters)
c = spatial.Candidates(v, 0)
clocs = np.array([[-1, 0, 1]]).T
c.add(clocs)
e = spatial.Election(v, c)
e.run('score')
self.assertTrue(np.all(e.result.winners == 1))
def test1():
v = spatial.Voters(seed=0, )
v.add_random(50)
seed = None
c = spatial.Candidates(
voters=v,
seed=seed,
)
c.add_random(12)
e = spatial.Election(voters=v, candidates=c, seed=2)
# e.run(method=ranked_pairs, btype='rank')
e.run(etype='ranked_pairs')
def run_majority_metric(seed=0):
v = spatial.Voters(seed=seed, tol=None)
v.add_random(100)
c = spatial.Candidates(v, seed=seed)
c.add_random(3)
c.add_random(2, sdev=2)
e = spatial.Election(v, c, seed=seed)
e.run('plurality')
# Retrieve output
ties = e.result.ties
winners = e.result.winners
ballots = e.result.ballots
stats = ElectionStats(voters=v.data,
candidates=c.data)
# check plurality stat is correct
stat_winner = stats.candidates.winner_plurality
print('stat winner =', stat_winner)
print('election winner=', winners)
votecount = ballots.sum(axis=0)
votecount2 = stats.candidates._winner_plurality_calcs[2]
# Make sure counts for plurality are the same for election & metric
assert np.all(votecount == votecount2)
print(votecount)
if len(ties) == 0:
assert stat_winner in winners
maxvotes = np.max(votecount)
numvoters = len(ballots)
# check majority winner stat
if maxvotes > numvoters / 2:
s = ('there should be majority winner, '
'%s out of %s' % (maxvotes, numvoters))
print(s)
assert stats.candidates.winner_majority in winners
def test_spatial(self):
numvoters = 99
num_candidates = 20
for ii in range(50):
v = spatial.Voters(seed=ii,)
v.add_random(numvoters=numvoters, ndim=2, )
c = spatial.Candidates(voters=v, seed=0)
c.add_random(cnum=num_candidates, sdev=1.0)
e = spatial.Election(voters=v, candidates=c)
scores = e.ballotgen.get_honest_ballots(
etype=votesim.votemethods.SCORE
)
winners, ties, output = score.sequential_monroe(scores, numwin=6)
return
def test_plurality_chain():
"""Test re-using honest election data to initialize
strategic runs."""
pref = [-1]*7 + [-0.5]*2 + [0.5]*3 + [1]*5
pref = np.array(pref)[:, None]
v = spatial.Voters(seed=0)
v.add(pref)
# Generate candidate preferences
cpref = [-1, -.5, .5, 1]
cpref = np.array(cpref)[:, None]
c = spatial.Candidates(v)
c.add(cpref)
# Run honest
e1 = spatial.Election(voters=v, candidates=c)
e1.run('plurality',)
tally1 = e1.result.runner.output['tally']
result1 = e1.result
assert np.all(tally1 == np.array([7, 2, 3, 5]))
# Run tactical
strategy = {'tactics' : 'bullet_preferred',
'ratio' : 1,
'underdog' : None,
'subset' : ''
}
s1 = spatial.Strategies(v).add(**strategy)
e1.set_models(strategies=s1)
e1.run('plurality', result=result1)
tally2 = e1.result.runner.output['tally']
assert np.all(tally2 == np.array([9, 0, 0, 8]))
# Run one sided
strategy = {'tactics' : 'bullet_preferred',
'ratio' : 1,
'underdog' : None,
'subset' : 'underdog'}
s1 = spatial.Strategies(v).add(**strategy)
e1.set_models(strategies=s1)
e1.run('plurality', result=result1)
tally3 = e1.result.runner.output['tally']
assert np.all(tally3 == np.array([7, 2, 0, 8]))
return locals()
def test_rerunner(self):
v = spatial.Voters(0)
v.add_random(20, 1)
c = spatial.Candidates(v, 0)
c.add([[0], [1], [2]])
e = spatial.Election(voters=v, candidates=c)
e.run(etype='irv')
e.run(etype='plurality')
series = e.dataseries()
e2 = e.rerun(series)
series2 = e2.dataseries()
for key in series2.keys():
print(key, series[key])
assert np.all(series[key] == series2[key])
def test_score_compare(self):
"""Sequential monroe ought to devolve to score at numwinners=1"""
numvoters = 50
num_candidates = 6
for ii in range(50):
v = spatial.Voters(seed=ii,)
v.add_random(numvoters=numvoters, ndim=2, )
c = spatial.Candidates(voters=v, seed=0)
c.add_random(cnum=num_candidates, sdev=1.0)
e = spatial.Election(voters=v, candidates=c)
scores = e.ballotgen.get_honest_ballots(
etype=votesim.votemethods.SCORE
)
winners1, ties1, output = score.sequential_monroe(scores, numwin=1)
winners2, ties2, output = score.score(scores, numwin=1)
assert np.all(winners1 == winners2)
assert np.all(ties1 == ties2)
def test_run():
for seed in range(50):
v = spatial.Voters(seed=seed)
v.add_random(20)
c = spatial.Candidates(v, seed=seed)
c.add_random(6)
e = spatial.Election(
voters=v,
candidates=c,
seed=0,
)
e.run('maj_judge')
# scores = e.output[0]['round_history']
scores = e.result.runner.output['round_history']
print('ratings for each elimination round')
print(scores)
print('winner=%s' % e.result.winners)
print('')
def test_ranked_deep_bury_onesided():
"""Test one sided burial strategy.
For one-sided, only the under-dog voters vote tactically.
* Honest Condorcet winner is Candidate #1.
* Runner up is Candidate #2.
* Therefore only #2 voters vote strategically in this scenario.
Outcomes
-------
It seems like burial backfires again in this scenario.
"""
v = spatial.Voters(seed=0)
v.add(voter_pref)
c = spatial.Candidates(v)
c.add(candidate_pref)
strategy = {
'tactics': 'deep_bury',
'subset': 'underdog',
'ratio': 1,
'underdog': None,
'frontrunnertype': 'eliminate'
}
s2 = spatial.Strategies(v).add(**strategy)
e2 = spatial.Election(voters=v, candidates=c, strategies=s2)
e2.run('ranked_pairs')
right = [[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3],
[1, 2, 3], [3, 1, 2], [3, 1, 2], [3, 1, 2], [3, 0, 1], [3, 0, 1],
[3, 0, 1], [3, 0, 1], [3, 0, 1]]
right = votesim.votemethods.tools.rcv_reorder(right)
ballots = e2.result.ballots
ballots = votesim.votemethods.tools.rcv_reorder(ballots)
assert np.all(right == ballots)
return
def test_plurality_ratio():
"""Test adjusted the ratio of tactical to honest voters"""
v = spatial.Voters(seed=0)
v.add_random(100)
c = spatial.Candidates(voters=v, seed=1)
c.add_random(5)
e1 = spatial.Election(voters=v, candidates=c)
result1 = e1.run('plurality')
tally1 = e1.result.runner.output['tally']
print('---------------------------------------')
for tacti_num in [0, 10, 25, 50, 75, 100]:
ratio = tacti_num / 100.
strategy = {'tactics' : 'bullet_preferred',
'ratio' : ratio,
'underdog' : None,
'subset' : ''}
s1 = spatial.Strategies(v).add(**strategy)
e1.set_models(strategies=s1)
e1.run('plurality', result=result1)
tally2 = e1.result.runner.output['tally']
print('vote tally =', tally2)
bgen = e1.ballotgen
tactical_ballots = bgen.tacticalballots
num_tactical_voters = len(tactical_ballots.group_index['tactical-0'])
# check that tactical voters number is correct
assert num_tactical_voters == tacti_num
# check that total voters in group index is correct.
group_index = tactical_ballots.group_index
count1 = len(group_index['honest-0'])
count2 = len(group_index['tactical-0'])
assert count1 + count2 == 100
count3 = len(group_index['topdog-0'])
count4 = len(group_index['underdog-0'])
assert count3 + count4 == count2
return
def test():
seed = None
for i in range(10):
v = spatial.Voters(seed=seed)
v.add_random(20, 3)
c = spatial.Candidates(v, seed=seed)
c.add_random(4)
e = spatial.Election(v, c, scoremax=5)
b = e.ballotgen.honest_ballot_dict
# e.result.
p1 = condcalcs.pairwise_scored_matrix(b['rate'])
p2 = condcalcs.pairwise_rank_matrix(b['rank'])
p3 = condcalcs.pairwise_scored_matrix(b['score'])
w1, *args = condcalcs.condorcet_winners_check(matrix=p1)
w2, *args = condcalcs.condorcet_winners_check(matrix=p2)
w3, *args = condcalcs.condorcet_winners_check(matrix=p3)
s1 = condcalcs.smith_set(vm=p1)
s2 = condcalcs.smith_set(vm=p2)
s3 = condcalcs.smith_set(vm=p3)
print('')
print(w1, w2, w3)
print(s1, s2, s3)
w, t, o = condorcet.smith_score(b['score'])
print('winner', w)
print(o)
assert np.all(p1 == p2)
if len(w1) > 0:
assert w1 == w2
def model(
name,
methods,
seed=0,
numvoters=100,
cnum=3,
trialnum=1,
ndim=1,
strategy='candidate',
stol=1,
):
"""Define election model here """
e = spatial.Election(None, None, seed=seed, name=name)
v = spatial.Voters(seed=seed, strategy=strategy, stol=stol)
v.add_random(numvoters, ndim=ndim)
v.electionStats.set_categories([], fulloutput=True)
cseed = seed * trialnum
for trial in range(trialnum):
c = spatial.Candidates(v, seed=trial + cseed)
c.add_random(cnum, sdev=1.5)
e.set_models(voters=v, candidates=c)
# Save parameters
e.user_data(num_voters=numvoters,
num_candidates=cnum,
num_dimensions=ndim,
strategy=strategy,
voter_tolerance=stol)
for method in methods:
e.run(etype=method)
return e
def test_metrics_compare():
"""Test plurality bullet voting strategy.
Scenario attributes:
- 3 candidate race with 3 concentrated, coincident voter groups
>>> Candidates #0 #1 #2
>>> Preference locations = [-1, 0.5, 1]
>>> Number of voters = [ 7, 3, 5]
- If voters are honest, plurality candidate #0 should win with 7 votes
- If voters are strategic and consider only the top two candidates,
Candidate #1 supporters also lean towards #2 - therefore
candidate #2 should win with 3 + 5 = 8 votes.
"""
pref = [-1] * 7 + [0.5] * 3 + [1] * 5
pref = np.array(pref)[:, None]
v = spatial.Voters(seed=0)
v.add(pref)
cpref = [-1, .5, 1]
cpref = np.array(cpref)[:, None]
c = spatial.Candidates(v)
c.add(cpref)
#####################################################################
# Run honest election
e1 = spatial.Election(voters=v, candidates=c)
e1.run('plurality')
result1 = e1.result
estat1 = result1.stats
#####################################################################
# Run strategic election
strategy1 = {
'tactics': 'bullet_preferred',
'subset': '',
'ratio': 1,
'underdog': None
}
s = spatial.Strategies(v)
s.add(**strategy1)
e1.set_models(strategies=s)
e1.run('plurality', result=result1)
result2 = e1.result
estat2 = result2.stats
#####################################################################
# Run the assestions
tc = votesim.metrics.TacticCompare(estat2, estat1)
t = e1.ballotgen.tacticalballots
topdog_num = len(t.group_index['topdog-0'])
underdog_num = len(t.group_index['underdog-0'])
regret1 = estat1.winner.regret
regret2 = estat2.winner.regret
regret_change = tc.regret
# Make sure regret change adds up for tactical and honest voters
assert regret2 - regret1 == regret_change['tactical-0']
# Make sure group regrets add up for the total reget, honest.
regret_honest = tc._group_honest.regret
regret1a = ((regret_honest['topdog-0'] * topdog_num +
regret_honest['underdog-0'] * underdog_num) /
(topdog_num + underdog_num))
assert regret1a == regret1
# Make sure group regrets add up for the total reget, tactical.
regret_strate = tc._group_strate.regret
regret2a = ((regret_strate['topdog-0'] * topdog_num +
regret_strate['underdog-0'] * underdog_num) /
(topdog_num + underdog_num))
assert regret2a == regret2
return e1, estat2, estat1
def tactical_model_v2(
name: str,
methods: list,
seed=0,
numvoters=51,
cnum=5,
cstd=1.5,
ndim=1,
tol=None,
ratio=1.0,
) -> spatial.Election:
"""Tactical Election model that test every single candidate as an underdog,
and tests topdog resistance using bullet voting.
"""
e = spatial.Election(None, None, seed=seed, name=name)
# Construct base strategy
strategy_base = {}
strategy_base['ratio'] = ratio
strategy_base['subset'] = 'underdog'
# Create underdog strategy
strategy2 = strategy_base.copy()
# Create topdog strategy
strategy3 = strategy_base.copy()
strategy3['tactics'] = ['bullet_preferred']
strategy3['subset'] = 'topdog'
# Generate voters
v = spatial.Voters(seed=seed, tol=tol, base='linear')
v.add_random(numvoters, ndim=ndim)
# Generate candidates
c = spatial.Candidates(v, seed=seed)
c.add_random(cnum, sdev=cstd)
e.set_models(voters=v, candidates=c)
# Construct election identification
eid = (
seed,
numvoters,
cnum,
ndim,
)
for method in methods:
# Set empty (honest) strategy
e.set_models(strategies=spatial.StrategiesEmpty())
e.user_data(eid=eid, strategy='honest')
result1 = e.run(etype=method)
winner = result1.winners[0]
stats_honest = result1.stats
underdog_list = list(range(cnum))
underdog_list.remove(winner)
# test each underdog
for underdog in underdog_list:
strategy2['underdog'] = underdog
strategy3['underdog'] = underdog
# test each tactic
tactics = get_tactics(method)
for tactic in tactics:
strategy2['tactics'] = tactic
# Run one-sided strategy
s = spatial.Strategies(v).add(**strategy2)
e.set_models(strategies=s)
e.user_data(eid=eid, strategy='one-sided')
result2 = e.run(etype=method, result=result1)
# Create tactical comparison output, add to output
tactic_compare = TacticCompare(e_strat=result2.stats,
e_honest=stats_honest)
e.append_stat(tactic_compare)
# Run two-sided strategy with top-dog bullet vote.
s.add(**strategy3)
e.set_models(strategies=s)
e.user_data(eid=eid, strategy='two-sided')
result3 = e.run(etype=method, result=result1)
# Create tactical comparison output, add to output
tactic_compare = TacticCompare(e_strat=result3.stats,
e_honest=stats_honest)
e.append_stat(tactic_compare)
return e
def tactical_model(
name: str,
method: str,
seed=0,
numvoters=51,
cnum=5,
ndim=1,
tol=None,
ratio=1.0,
frontrunnernum=2,
) -> spatial.Election:
"""Tactical Election model """
e = spatial.Election(None, None, seed=seed, name=name)
# Construct base strategy
strategy_base = {}
strategy_base['ratio'] = ratio
strategy_base['frontrunnernum'] = frontrunnernum
strategy_base['frontrunnertype'] = 'eliminate'
# strategy_base['tactics'] = ('bury', 'compromise')
strategy_base['tactics'] = ('minmax_preferred')
strategy_base['subset'] = 'underdog'
strategy2 = strategy_base.copy()
# Generate voters
v = spatial.Voters(seed=seed, tol=tol, base='linear')
v.add_random(numvoters, ndim=ndim)
# Generate candidates
c = spatial.Candidates(v, seed=seed)
c.add_random(cnum, sdev=1.0)
e.set_models(voters=v, candidates=c)
# Set empty (honest) strategy
e.set_models(strategies=())
result1 = e.run(etype=method)
winner = result1.winners[0]
stats_honest = result1.stats
underdog_list = list(range(cnum))
underdog_list.remove(winner)
try:
print('honest tally')
print(result1.runner.output['tally'])
print('')
except KeyError:
pass
# test each underdog
for underdog in underdog_list:
# Run one-sided strategy
strategy2['underdog'] = underdog
s = spatial.Strategies(v).add(strategy2, 0)
e.set_models(strategies=s)
result2 = e.run(etype=method, result=result1)
# Create tactical comparison output, add to output
tactic_compare = TacticCompare(e_strat=result2.stats,
e_honest=stats_honest)
e.append_stat(tactic_compare)
series = e.dataseries()
out1 = series[statnames[0]]
out2 = series[statnames[1]]
print('Setting underdog = %s' % underdog)
print('Topdog VSE = %.2f' % out1)
print('Underdog VSE = %.2f' % out2)
print('winner=%s' % result2.winners[0])
try:
print('tally=', result2.runner.output['tally'])
except KeyError:
pass
# print(result2.ballots)
print('')
# Calculate underdog using tally
s0 = spatial.Strategies(v).add(strategy_base, 0)
e.set_models(voters=v, candidates=c, strategies=s0)
e.run(etype=method)
frunners = e.ballotgen.tacticalballots.root.get_group_frontrunners(s0.data)
print('calculated front runners (tally) = ', frunners)
#Calculate underdog using eliminate
strategy_base['frontrunnertype'] = 'eliminate'
s0 = spatial.Strategies(v).add(strategy_base, 0)
e.set_models(voters=v, candidates=c, strategies=s0)
e.run(etype=method)
frunners = e.ballotgen.tacticalballots.root.get_group_frontrunners(s0.data)
print('calculated front runners (eliminate) = ', frunners)
return e
import numpy as np
from votesim.models import spatial
from votesim.strategy.stratrunner import StrategicRunner
logging.basicConfig()
logger = logging.getLogger('votesim.strategy')
logger.setLevel(logging.WARNING)
method = 'plurality'
cnum = 5
vnum = 31
ndim = 2
name = 'strat-1'
record = None
for seed in range(10, 30):
v = spatial.Voters(seed=seed)
v.add_random(vnum, ndim=ndim)
c = spatial.Candidates(v, seed=seed)
c.add_random(cnum, sdev=1.5)
srunner = StrategicRunner(name,
method,
voters=v,
candidates=c,
record=record)
record = srunner.record
print('\n')
print('VSE honest', srunner.vse_honest)
print('VSE 1-sided', srunner.vse_onesided)
try:
print('VSE change, underdog', np.max(srunner.dvse_underdogs))
def test_plurality_onesided():
"""Test plurality one sided voting strategy.
- #0 would win if #1 voters are strategic.
- #3 will win if #1 are honest and #2 voters use one-sided strategy.
>>> Candidates #0 #1 #2 #3
>>> Preference locations = [-1, -0.5, 0.5, 1]
>>> Number of voters = [ 7, 2, 3, 5]
"""
# Generate voter preferences
pref = [-1]*7 + [-0.5]*2 + [0.5]*3 + [1]*5
pref = np.array(pref)[:, None]
v = spatial.Voters(seed=0)
v.add(pref)
# Generate candidate preferences
cpref = [-1, -.5, .5, 1]
cpref = np.array(cpref)[:, None]
c = spatial.Candidates(v)
c.add(cpref)
#####################################################################
# Run honest election
e1 = spatial.Election(voters=v, candidates=c)
e1.run('plurality')
tally1 = e1.result.runner.output['tally']
result1 = e1.result
assert np.all(tally1 == np.array([7, 2, 3, 5]))
assert 0 in e1.result.winners
#####################################################################
# Run one-sided tactical election
strategy1 = {'tactics' : 'bullet_preferred',
'ratio' : 1,
'subset' : 'underdog',
'underdog' : None,}
strat1 = spatial.Strategies(v).add(**strategy1)
e2 = spatial.Election(voters=v, candidates=c, strategies=strat1)
result2 = e2.run('plurality', result=result1)
tally2 = result2.runner.output['tally']
assert np.all(tally2 == np.array([7, 2, 0, 8]))
assert 3 in result2.winners
# Test metric comparison system.
tc = TacticCompare(e_strat=result2.stats,
e_honest=result1.stats,
)
# e2.electionStats.add_output(tc)
stats2 = result2.stats
stats1 = result1.stats
print('---------------------------------------')
print('one-sided regret change =', tc.regret)
print('')
print('one-sided VSE change = ', tc.regret_efficiency_candidate)
print('')
print('VSE tactical = ', stats2.winner.regret_efficiency_candidate)
print('VSE honest = ', stats1.winner.regret_efficiency_candidate)
#####################################################################
# Run full tactical election
strategy1 = {'tactics' : 'bullet_preferred',
'ratio' : 1,
'underdog' : None,
'subset' : ''}
strat1 = spatial.Strategies(v).add(**strategy1)
e3 = spatial.Election(voters=v, candidates=c, strategies=strat1)
result3 = e3.run('plurality', result=result1)
tally3 = result3.runner.output['tally']
assert np.all(tally3 == np.array([9, 0, 0, 8]))
assert 0 in result3.winners
# Test metric comparison system.
tc = TacticCompare(e_strat=result3.stats,
e_honest=result1.stats,
)
print('')
print('two-sided regret change =', tc.regret)
print('two-sided VSE change = ', tc.regret_efficiency_candidate)
docs = result3.output_docs
# Try to append new output to election results
e3.append_stat(tc)
df = e3.dataframe()
# pdb.set_trace()
return df
def tactical_model(
name: str,
methods: list,
seed=0,
numvoters=100,
cnum=3,
ndim=1,
tol=None,
ratio=1.0,
) -> spatial.Election:
"""Tactical Election model where voters use naive underdog prediction. """
e = spatial.Election(None, None, seed=seed, name=name)
# Construct base strategy
strategy_base = {}
strategy_base['ratio'] = ratio
strategy_base['underdog'] = None
# Generate voters
v = spatial.Voters(seed=seed, tol=tol, base='linear')
v.add_random(numvoters, ndim=ndim)
# Generate candidates
c = spatial.Candidates(v, seed=seed)
c.add_random(cnum, sdev=2.0)
e.set_models(voters=v, candidates=c)
# Construct election identification
eid = (
seed,
numvoters,
cnum,
ndim,
)
# Loop through election methods
for method in methods:
# Retrieve topdog strategy.
strategy_topdog = get_topdog_strategy1(method)
strategy_topdog['ratio'] = ratio
strategy_topdog['subset'] = 'topdog'
strategy_topdog['underdog'] = None
# First run the honest election
e.user_data(
eid=eid,
num_voters=numvoters,
num_candidates=cnum,
num_dimensions=ndim,
strat_id=-1,
onesided=False,
)
# Set empty (honest) strategy
e.set_models(strategies=spatial.StrategiesEmpty())
result1 = e.run(etype=method)
stats_honest = result1.stats
# honest_ballots = e.ballotgen.honest_ballots
# stats_honest = e.electionStats.copy()
# Initialize strategy elections
strategies = get_strategies1(method)
for s in strategies:
s.update(strategy_base)
# Iterate through available strategies
for ii, strategy in enumerate(strategies):
# Run one-sided strategy
strategy['subset'] = 'underdog'
s = spatial.Strategies(v).add(**strategy)
e.set_models(strategies=s)
e.user_data(eid=eid,
num_voters=numvoters,
num_candidates=cnum,
num_dimensions=ndim,
strat_id=ii,
onesided=True)
result2 = e.run(etype=method, result=result1)
# Create tactical comparison output, add to output
tactic_compare = TacticCompare(e_strat=result2.stats,
e_honest=stats_honest)
e.append_stat(tactic_compare)
# Run defensive topdog strategy
s = s.add(**strategy_topdog)
e.set_models(strategies=s)
e.user_data(
eid=eid,
num_voters=numvoters,
num_candidates=cnum,
num_dimensions=ndim,
strat_id=ii,
onesided=False,
)
result3 = e.run(etype=method, result=result1)
tactic_compare = TacticCompare(e_strat=result3.stats,
e_honest=stats_honest)
e.append_stat(tactic_compare)
return e
from votesim.models import spatial, spatialerror
widths = [0, .1, .2, .3, .4, .5]
errors = []
for error_width in widths:
v1 = spatialerror.ErrorVoters(seed=0)
v1.add_random(1000, 1, error_mean=0.0, error_width=error_width)
c = spatial.Candidates(v1, seed=0)
c.add_random(6)
e1 = spatial.Election(v1, c, seed=0)
dist_error = e1.ballotgen.distances
v2 = spatial.Voters(seed=0)
v2.add(v1.pref)
e2 = spatial.Election(v2, c, seed=0)
dist_true = e2.ballotgen.distances
error = np.sum(np.abs(dist_error - dist_true))/ len(dist_true)
errors.append(error)
print(error)
errors = np.array(errors)
condition = np.argsort(errors) == np.arange(len(errors))
assert np.all(condition)
assert np.all(errors[1:] > 0)
assert np.all(np.diff(errors) > 0)
