[EM] STV and weighted positional methods

[Kristofer Munsterhjelm]

Kathy Dopp wrote:
> On Sun, Feb 1, 2009 at 6:01 AM, Raph Frank <raphfrk at gmail.com> wrote:
>> Party list systems are (mostly) monotonic.
> 
> Do not know what "Party list systems" are, but all plurality elections
> are monotonic.

A party list system works like this. You have one vote. Vote for a 
party. The number of votes are counted, and then each party gets a share 
of the assembly proportional to the number of votes it got. Each party 
has a list, and if a party gets (say) four seats in the assembly, the 
first four candidates on the list are elected to the assembly.

Here's an example: there are three parties, the assembly is of size ten. 
We'll use Webster's method, since it's most fair (possibly with the 
exception of Warren's dynamic method).

The first party fields: A1, A2, A3, A4, A5, A6, A7, A8, A9, A10. The 
same for the second and third parties, except their candidates start 
with B and C respectively.

Run the election. Say the vote counts are:
	Party A: 847 votes = v_1
	Party B: 300 votes = v_2
	Party C: 640 votes = v_3

Now we need to pick x so that round(v_1 / x) + round(v_2 / x) + 
round(v_3 / x) = 10 (size of the assembly).

It's rather easy to find x by just trying[1]. In this case, x = 160 
works, and you get:

	Party A: round(847 / 160) = 5 seats
	Party B: round(300 / 160) = 1 seat
	Party C: round(640 / 160) = 4 seats

which sums up as desired. To find out which candidates the parties got, 
just read off the list. There are five from the first party: A1 A2 A3 A4 
A5; then there is one from the second party: B1; then there are four 
from the third party: C1 C2 C3 C4.

The assembly is A1 A2 A3 A4 A5 B1 C1 C2 C3 C4.

Open list PR works like this, but also lets the voters influence the 
order of the lists.

When comparing STV to party list, I don't like party list PR that much 
(since it makes parties formally a part of the process), but party list 
*is* both simple and proportional, and the results are much better than 
those given by a two-party system.

-

[1] the function (size of assembly) - (round(v_1 / x) + round(v_2 / x) + 
round(v_3 / x)) crosses zero at the desired value of x, and it's also 
rather linear and certainly monotone, so we can use root finding with 
little trouble, or just try it manually. As an aside, it might be 
interesting to determine the asymptotic runtime of the fastest algorithm 
that finds x.