[EM] A possible solution to SNTV vote-splitting

[Kristofer Munsterhjelm]

One problem of SNTV (which is monotone), even the cumulative 
redistributing version I showed earlier, is that voters can spread their 
support too thin. This corresponds Plurality's infamous vote-splitting 
"feature", and shouldn't be very surprising, given that SNTV is 
basically multiwinner Plurality.

However, SNTV is proportional under strategy. When parties field 
candidates proportional to their support (and to the number of seats 
given), none of the parties can benefit from adding more candidates nor 
from removing any of their candidates (assuming that the voters are 
loyal and distribute their Plurality votes equally among the party 
candidates).

So why not have the method devise its own strategy? Like ordinary DSV, 
the method should be in a better position to do so than the voters 
themselves, because the method has access to all the ballots whereas the 
voters only have polls. If the stable outcome is proportional, as it 
seems to be in SNTV, then handling strategy behind the scenes should 
grant that proportionality.

The trick, of course, is to have the strategy transformation preserve 
monotonicity. I'll give one possible way of doing the transformation. As 
far as I can see (though I haven't thought about it for that long), it 
seems to preserve monotonicity - there are some murky areas, but I'll 
give them later.

The easiest way for voters to combat vote-splitting is to find a common 
candidate: in other words, to reduce the vote of some candidate, or 
simply not vote for him. To minimize butterfly effect problems, I'll use 
cumulative vote SNTV, but it might be possible to use my idea for 
ordinary SNTV as well (although the plurality ballots would have to 
become ranked ballots in that case).

Therefore, we can imagine, as a strategy, some voters giving candidates 
they would otherwise give some positive amount of points, none instead. 
They would only do so if it would benefit them (produce a better outcome 
from their point of view), and voters who would lose by doing so would 
obviously not do so.

That suggests the following measure: say we want to determine if 
eliminating a certain coalition is a good idea. For some voter i, denote 
cold_i the score he gives the current council (outcome) - just the sums 
of the ratings for those candidates that are in the outcome; and denote 
cnew_i the score he gives the new council (outcome after elimination). 
Then the "improvement score" is equal to the sum, across every voter v, 
of min(0, cnew_v - cold_v).

The mechanics of the method is then: for every elimination that has a 
positive improvement score, check if those that would benefit could, by 
acting alone, change the old outcome into the new outcome. The point of 
that check is to prevent the effective withdrawal of a winner just 
because some very small minority would benefit. Among those where the 
voters that would benefit could pull it off by themselves, pick the one 
with the greatest improvement score, then restart. Continue until there 
is no move that can improve the outcome.

Note that unlike a candidate withdrawal option, only those who actually 
benefit from the change make the change - the candidate isn't 
eliminated. Also, when dealing with cumulative vote SNTV, ballots are 
renormalized after removing a candidate.

By considering coalitions and not just single candidates, this idea may 
be more resistant to the problem that appears in STV: that the order of 
eliminations matter. By doing as much as possible in one go, it should 
matter much less. The question is whether it matters sufficiently little 
that the method remains monotone. I don't know that, yet.

Since SNTV has only a vote-splitting problem, not both that and a 
teaming problem, subsequent eliminations should bring it closer to 
proportionality until some optimum has been reached. To put it in 
another way: artificially ranking low too many candidates never helps. 
Still, there might be local optima - again, I don't know that. If so, 
then the order of the "moves" would matter: eliminating coalition X 
suggests eliminating coalition Y, but eliminating coalition Y doesn't 
suggest eliminating coalition X.

Thus there are still unknowns, but the general idea appears interesting 
(and of use).