Talk:Task:Define voting procedure for Community Council elections

It seems we don't have TeX enabled here... Dumping original content here, and will edit the main page to render it readable. If we get TeX, this may be pasted back...

Contents

[edit] Proposal: RRV

[edit] Variables

  • l: number of voters
  • m: number of candidates
  • n: number of seats
  • i: index of voters (1 \le i \le l)
  • j: index of candidates (1 \le j \le m)
  • k: index of seats (and rounds) (1 \le k \le n)

[edit] Parameters

A range for votes is selected by two limits, amax and amin. Reasonable choices include:

  • amin = 0, amax = 1 (unbalanced, normalized)
  • amin = − 1, amax = 1 (balanced)
  • amin = 0, amax = 100 (unbalanced percentage; potentially useful if ratings were to be quantized)

The effects of the voting system are generally independent of the limits selected, but a balanced range may be preferred by some voters to permit unknown candidates to be rated 0 with known, disliked candidates rated negative. Obviously this effect may be accomplished in an unbalanced range by rating unknown candidates \tfrac{a_{min} + a_{max}}{2}. Some calculations are simplified by using the unbalanced, normalized range, which makes it preferable from a numerical perspective.

A ballot from voter i consists of m ratings aij for the m candidates, such that a_{min} \le a_{ij} \le a_{max}.

[edit] Procedure

After all ballots are collected, n rounds are held to choose the winners wk, with one winner chosen per round. In the first round, the weighted ratings for each voter are initialized as bij1 = aij. The weighted scores in each round are summed:

B_{jk}=\sum_{i=1}^{l}b_{ijk}

The highest-scoring candidate not yet elected wins; this is not simple to express formally:

w_k = \max ( B_{jk} \ni j \notin w_{1 \cdots k-1})

The weighted scores for each succeeding round are calculated by de-emphasizing ballots according to the portion in which they've already won:

b_{ij(k+1)}=\frac{a_{ij}}{1+\sum_{p=1}^{k}\tfrac{a_{iw_p}-a_{min}}{a_{max}-a_{min}}}

In the case of an unbalanced range (amin = 0), b_{ij(k+1)}=\frac{a_{ij}}{1+\sum_{p=1}^{k}\tfrac{a_{iw_p}}{a_{max}}}, and in the normalized case (amax = 1), b_{ij(k+1)}=\frac{a_{ij}}{1+\sum_{p=1}^{k}a_{iw_p}}.

[edit] Discussion

It seems to me like this voting system requires voters to understand at least a little game theory. It looks far too complicated to be used in a real-life election.

The voting system used should, in my opinion, require the voter to do one of three things:

  • Choose candidates in order of preference (1, 2, 3...)
  • Choose 1 favourite candidate
  • Choose their N favourite candidates from the electorate (the GNOME system)

Of the three choices, the GNOME system is my least favourite, and the straight vote seems a little limiting. I prefer simple preferential voting.

Of the simple preferential voting systems, my favourite is single transferable vote. It's better than Condorcet, in my opinion, because it is understandable quite easily by the electorate and does not produce unexpected results (such as someone who was no-one's favourite candidate getting elected).

--Dave Neary 18:39, 3 December 2008 (UTC)

From the voter's perspective, I don't see score ballots as requiring more game theory knowledge than ranked ballots. Both require voters assigning numbers to some or all candidates, but preferential ballots make it more complex, by adding constraints on those numbers. All voters have to do (perhaps I wasn't clear on this, as I was emphasizing the underlying mechanics) is assign a score from 0 to 1 (ideally continuous, but possibly discretized) to each candidate, reflecting the value they assign to that candidate's winning.
I think score ballots are better because they are simpler and more expressive. Since there are no possible invalid ballots, there is no need to keep the ballot valid (by dynamically altering the voter's previous input), or to reject invalid ballots (and throw the voter back to fix the invalid ballot). The score ballot also carries more information because it preserves the relative magnitude of preferences, while ranked methods consider only the direction.
Another ballot system you didn't mention is approval ballots (the extreme discretization of score ballots; simply a checkbox by each candidate); these enjoy all the simplicity of the GNOME system, but are intermediate in expressiveness with preferential ballots, so I'd rate them a more desirable choice than GNOME. They also inherit from score ballots the lack of invalid ballots, allowing a simpler voting process than either preference or GNOME; however, I'm not real sure on other counting methods for approval ballots (besides, obviously, the reweighting algorithm as proposed).
As for "far too complicated", are you referring to the voter's perspective, or the implementation of the scoring mechanics? If the latter, it may be because I (a non-mathie) was trying to state things formally. I considered whipping up some C or Octave code to demonstrate, and can still do that if it's helpful. It seems substantially simpler to me than effective STV counting methods, such as Meek counting, and has the benefit of being deterministic and finite-depth, making it seem more likely to be numerically robust, and simple to implement. (I'm also aware of substantially less work on multi-winner score-ballot methods, so the proposed reweighting may be gaining simplicity at the cost of using the ballot information less efficiently than Meek/STV does, but the additional information expressed in score ballots does compensate for this...) --benson 23:10, 3 December 2008 (UTC)
Retrieved from "http://bugs.maemo.org/Talk:Task:Define_voting_procedure_for_Community_Council_elections"