[EM] Ratings Proportional Method (IRNRP)

[Brian Olson]

Kevin Bass' work on rethinking STV encouraged me to dig out my old
proportional method and dust it off.
Kevin outlines two trial elections that many formulations of STV will
produce an unsatisfying outcome for.

http://blog.opavote.com/2016/06/guest-post-rethinking-stv-fundamentals.html

My system gets those two tests right, and I think has some other good
qualities worth discussing.

I call my system *"Instant Runoff Normalized Ratings, Proportional"
(IRNRP).* If you've been following this discussion forum for enough years,
you may have heard me talk about the single-winner variant.

*STV/IRV ignore useful information.* Because they only look at the
currently-top-ranked choice on each ballot, we get the classic IRV failure
mode of not electing a compromise candidate where there's good 2nd-choice
support but less 1st-choice support.

*IRNRP looks at the whole ballot*. Like most ratings based method, it
operates on summing up the ratings for each choice across all voters.

There are probably discontinuities/non-monotonic regions, but they are
probably smaller. In Ka Ping Yee style election space diagrams, the single
winner IRNR has much smaller discontinuous zones than IRV. I haven't ported
my IRNRP implementation to C for the fast simulation framework to generate
such a diagram, and those things are messier in multi-winner situation, but
it could be on the TODO list.

Also, given the recent talk of sharing programs, I've implemented it in
about 100 lines of Python:

https://bitbucket.org/bodhisnarkva/voteutil/src/
58bb573731df1f0c493c04189aa6b818637d9421/python/irnrp.py?at=
default&fileviewer=file-view-default

Read the source, or my *prose version of the algorithm*:

    Given a set of votes that are ratings from voters across some
    choices (higher rating better), elect several choices in proportion to
    their support in the voters.

    At any time a single vote is 'normalized' by dividing it by the
    sum of absolute values of its component ratings. The sum of
    absolute values of the ratings of the normalized vote should be
    1.0

    Each competing choice starts off with a 'weight' of 1.0

    Add up the votes, for each vote:
      Multiply each rating by the global weight for that chioice
      Normalize to 1.0 the sum of absolute values of ratings
      Add up these weighted-then-normalized votes

    A choice is considered elected if it has greater than the quota of:
    ((number of active voters) / ((number of seats to elect) + 1))

    If a sufficient number of choices are elected, we're done.

    The weight of each elected choice shall be decreased so that it
    receives less surplus vote but still greater vote than the needed
    quota to win. This may be repeated several times, doing a recount
    as above to integrate the new weights and the re-normalized votes
    which result.

    If adjusting the weights of the winners does not move enough
    surplus vote to elect a full set of winners, whichever choice has
    the least vote shall have its weight set to 0.0 and thus be
    disqualified. Re-count with re-normalized votes accounting for
    this choice having been removed from consideration.

    A voter can become 'inactive' and not counted in the total number
    of voters if all of the non-zero rated choices on their ballot
    have become disqualified.


If you check out the source:
hg clone https://bitbucket.org/bodhisnarkva/voteutil

You can run the two tests with commands like this:

python3 python/countvotes.py --html=/tmp/a.html - --enable-repeat
 --seats=3<<EOF
*12 a=9&b=8
*7 b=9&a=8
*9 r=9&s=8
*8 s=9&r=8
EOF

python3 python/countvotes.py --html=/tmp/b.html - --enable-repeat
 --seats=5<<EOF
*690 a=9&b=8&c=7&d=6&e=5&v=4&w=3&x=2&y=1&z=0.5
*310 v=10&w=9&x=8&y=7&z=6&a=5&b=4&c=3&d=2&e=1
EOF
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.electorama.com/pipermail/election-methods-electorama.com/attachments/20170101/94714e9f/attachment-0001.htm>