On Oct 14, 2008, at 12:11 PM, Raph Frank wrote:
On Tue, Oct 14, 2008 at 2:04 PM, Brian Olson <[EMAIL PROTECTED]> wrote:
Once upon a time, I designed an election method to fix the strategy
problem
with Range Voting.
The method I call "Instant Runoff Normalized Ratings" (IRNR):
1. Collect ratings ballots
2. Normalize each ballot so that each has an equal magnitude
Magnitude = max rating - min rating
or
Magnitude = sum of ratings (negative ratings allowed)
?
I mean the geometric sense. For ratings a,b,c,etc., sqrt(a*a + b*b +
c*c ...)
3. Sum up normalized ballots
4. If there are more than two choices, drop the one with the
smallest sum.
If there are two choices remaining, one is the winner.
5. Re-normalize from original ballot values but as if dropped choices
weren't there
6. Go to 3
I think it gets very near to a utilitarian ideal solution (
http://bolson.org/voting/twographs.html )
It id heard to determine which plot refers to which method.
In a sense, part of the result is that there's a pretty tight pack of
similar (good) results and a few outliers (IRV, pick-one).
and encourages people to vote
honestly and uses those honest votes to the best possible effect.
Maybe, I can't see any obvious strategy and it seems to protect people
from casting weak votes.
Its Instant Runoff nature does have some drawbacks. It is not
summable by
parts and requires all the data to be collected in one place.
It also has some small discontinuities in the Ka-Ping Yee diagrams:
http://bolson.org/voting/sim_one_seat/www/4c_IRNR.png
But at least it's not as bad as IRV:
http://bolson.org/voting/sim_one_seat/www/4c_IRV.png
I have some ideas about smoothing out the discontinuity, but
haven't gotten
around to trying it yet. I think the key is to make the process more
continuous and take smaller steps. Don't disqualify a choice all at
once,
but over several steps. Blend out the losing choices, blend out the
nasty
jumps in the decision process. Needs to be experimentally (in
simulator)
checked, though.
I am not so sure candidates need to actually be eliminated.
Candidates who are out of the running would still be rated by each
voter. However, they would not be used to determine the truncation
window used. Ofc, that could mean that the method doesn't converge.
This is especially true if there is a condorcet cycle.
For example, if a voter votes
A: 10
B: 3
C: 0
initially, the vote will just be rescaled to give maximum
window = (0,10)
A: 1.0
B: 0.3
C: 0.0
Each candidate would be assigned a score based on the result of the
first round, then the new window needs to be worked out
1.0 = in the running
0.0 = eliminated
For each ballot.
1) work out weighted mean using the scores.
- This will be the centre of the window
2) for each candidate work out
d(candidate) = (score)*(distance from mean)
3) determine the highest distance
4) Set window to
window( mean - dmax, mean + dman )
In the above example
score(A) = 1
score(B) = 1
score(C) = 0.5
mean = (1*10 + 1*3 + 0.5*0)/2.5 = 5.2
distance(A) = 1*4.8 = 4.8
distance(B) = 1*2.2 = 2.2
distance(C) = 0.5*5.2 = 2.6
dmax = 4.8
window = (5.2-4.8 , 5.2+4.8) = (0.4, 10)
The ballot would be rescaled as
A: 1.0
B: 0.27
C: 0
If only 2 candidates remain, then it will set the window as max and
min of those candidates.
I think that's pretty similar to what I'd planned to implement. I'm
still expecting some tinkering will be needed to get it to do
solutions with negligible instability.
----
Election-Methods mailing list - see http://electorama.com/em for list info
