Allocated Score

From Electowiki
Jump to navigation Jump to search

Allocated Score is a proportional representation voting method using 5 star ballots. Otherwise known as Proportional STAR Voting, this method is one of three voting methods in the STAR Voting family, which includes single-winner STAR voting, multi-winner Bloc STAR Voting, and Proportional STAR. In the multi-winner context STAR stands for Score Then Automatic Runoffs.

Allocation is the default mechanism for achieving proportional representation in voting methods. Winners are selected in rounds. Each round elects the candidate with the highest total score. After each selection, the Hare quota of ballots which scored the winner the highest is allocated to them, and as such those ballots are removed from subsequent rounds. Ballots on the cusp of the quota may only have their ballots partially allocated to ensure that voters who supported the winner equally are treated equally.

Description[edit | edit source]

A sample ballot for a STAR-PR election with 3 winners.

Winners in Proportional STAR Voting (Allocated Score) are selected in rounds. Each round elects the candidate with the highest total score and then designates a quota worth of voters from that candidate's strongest supporters as represented. Subsequent rounds include all voters who are not yet fully represented.

Classification[edit | edit source]

Allocated Score is a sequential, multi-winner, cardinal, Monroe type, proportional representation voting method.

Procedure[edit | edit source]

Each voter scores all candidates on a [0,5] scale

  1. Select the candidate with the highest sum of score as each round's winner.
  2. Set the ballot weight to zero for the quota of voters whose ballots contributed the highest scores to that winner.
    • If several voters have contributed the same score to the winner at the threshold of the quota then Fractional Surplus Handling is applied to those voters
  3. Repeat this process until all the seats are filled.

Fractional Surplus Handling: When determining which ballots belong to a winner's quota, voter’s ballots are sorted by the score they contributed to the winner's total score.

When multiple voters contributed the same score to the winner it may be the case that allocating them all to the winner would cause the quota to be exceeded but not allocating them all would cause the quota not to be met. For these voters on the cusp, an equal fraction of their ballot weight is allocated.

Fractional Surplus Handling ensures that voters who supported a candidate equally will be treated equally, while ensuring that the total weight of the ballots allocated for each winner will not exceed the Hare quota. It also preserves the Independence of Irrelevant Alternatives and Monotonicity criteria.

Note that with Fractional Surplus Handling voters can have a fractional ballot weight and they can subsequently only contribute that fraction to the remaining candidates, both during subsequent score tabulation and allocation.

Python Implementation[edit | edit source]

Given a Pandas dataframe S with columns representing candidates and rows representing voters the entries would encode the score of all the ballots. For a max score of K and a desired number of winners W.

import pandas as pd
import numpy as np

def Allocated_Score(K, W, S):

    #Normalize score matrix
    ballots = pd.DataFrame(S.values/K, columns=S.columns)
    
    #Find number of voters and quota size
    V = ballots.shape[0]
    quota = V/W
    ballot_weight = pd.Series(np.ones(V),name='weights')
    
    #Populate winners in a loop
    winner_list = []
    while len(winner_list) < W:

        weighted_scores = ballots.multiply(ballot_weight, axis="index")

        #Select winner
        w = weighted_scores.sum().idxmax()
    
        #Add winner to list
        winner_list.append(w)

        #remove winner from ballot
        ballots.drop(w, axis=1, inplace=True)
    
        #Create lists for manipulation
        cand_df = pd.concat([ballot_weight,weighted_scores[w]], axis=1).copy() 
        cand_df_sort = cand_df.sort_values(by=[w], ascending=False).copy()  
        
        #find the score where a quota is filled
        split_point = cand_df_sort[cand_df_sort['weights'].cumsum() < quota][w].min()
    
        #Amount of ballot for voters who voted more than the split point
        spent_above = cand_df[cand_df[w] > split_point]['weights'].sum()
        
        #Exhaust all ballots above split point
        if spent_above>0:    
            cand_df.loc[cand_df[w] > split_point, 'weights'] = 0.0
    
        #Amount of ballot for voters who gave a score on the split point
        weight_on_split = cand_df[cand_df[w] == split_point]['weights'].sum()

        #Fraction of ballot on split needed to be spent
        if weight_on_split>0:     
            spent_value = (quota - spent_above)/weight_on_split
    
            #Take the spent value from the voters on the threshold evenly
            cand_df.loc[cand_df[w] == split_point, 'weights'] = cand_df.loc[cand_df[w] == split_point, 'weights'] * (1 - spent_value)
    
        ballot_weight = cand_df['weights'].clip(0.0,1.0)

    return winner_list

Variants[edit | edit source]

Quota[edit | edit source]

A common variant is to use Droop quotas instead of Hare quotas to mitigate Free riding.

Sequential Monroe[edit | edit source]

Sequential Monroe can be thought of as a variant of Allocated Score with a change to the selection method.