[EM] IRV proponents figure out how to make IRV precinct-summable

Dave Ketchum davek at clarityconnect.com
Mon Mar 23 11:50:19 PDT 2009

```On Mar 23, 2009, at 10:46 AM, Kristofer Munsterhjelm wrote:

> Dave Ketchum wrote:
>> On Mar 22, 2009, at 4:24 PM, Kristofer Munsterhjelm wrote:
>>> As stated, it's not summable. But note that the second round,
>>> which is determined by the Plurality count, consists of a pairwise
>>> comparison. Thus, one can make the method summable by simply
>>> storing the information required to simulate any one-on-one runoff
>>> -- in other words, by having a Condorcet matrix. Since Condorcet
>>> is not mutually exclusive with summability, we know Condorcet
>>> matrices can be summed - so that part is summable. We also know
>>> that Plurality counts are summable - if A gets X votes in district
>>> 1 and Y votes in district 2, A got X+Y votes in these districts
>>> combined.
>> Agreed that Condorcet and Plurality, and even Approval, are summable.
>> But suppose voters say A>B>C and A>C>B:
>>     Condorcet will count A>B, A>B, A>C, A>C,  B>C, and C>B into the
>> N*N matrix.
>>     IRV will only see A>? and A>? until and unless A losing exposes
>> what remains (B>? or C>?).
>> True that ballot images could be forwarded, but that does not
>> really make summable claimable.
>
> Agreed (in turn) that forwarding ballot images doesn't make a method
> summable, since otherwise, any method that doesn't care about the
> order of the ballots would be "summable".
>
> Also, IRV, in the general case, is not summable. However, what we're
> talking about is the contingent vote, an "instant top-two runoff",
> which is what the IRV proponents figured out how to make precinct
> summable (or thought they had figured out how to make precinct
> summable). It agrees with IRV if the number of candidates <= 3.
>
> The contingent vote first counts plurality votes for the various
> candidates, as top-two runoff does. Then, again as in top-two
> runoff, the two "winners", Plurality wise, go to the next round. The
> difference is that the contingent vote uses the same rank ballots
> for the second round as for the first, only with all non-winners
> eliminated, whereas true TTR has a separate second round.

Let's see:
Plurality and Condorcet look  at the ballots ONE time, and never
go back.  Does summable require this - never going back to the
ballots, or to the voters, more times?
TTR needs to go back only if the top two were near to a tie -
IRV could do the same.
For TTR the second round presumably always finishes it; get
near enough to a tie and IRV could need more rounds - but they do not
mean extra effort from the voters.
>
>
> Let's have a concrete example of how the contingent vote works, and
> why my approach to it is summable.
>
> District 1:     100: A > B > C
>                 98: B > C > A
>                 27: C > A > B
>
> District 2:     104: C > B > A
>                121: C > A > B
>                 50: A > B > C
>                 25: B > A > C
>
> Combined:       104: C > B > A
>                150: A > B > C
>                148: C > A > B
>                 98: B > C > A
>                 25: B > A > C
>
> For the combined ballot, first do a Plurality count to see who
> advances. Note that this Plurality count is what makes contingent
> vote equal to IRV for number of candidates = 3, since preserving the
> top two is equal to eliminating the last candidate.
>
> Combined, plurality: 104 C, 150 A, 148 C, 98 B, 25 B
> hence:               252 C, 150 A, 123 B
>
> So C and A move to the second round.
>
> Eliminating B, we get
>                104: C > A
>                150: A > C
>                148: C > A
>                 98: C > A
>                 25: A > C
> summing up,
>                350: C > A
>                175: A > C
>
> So C wins.
>
> Let's look at the combined Condorcet matrix. It is
>
>  A    B    C    beats
> A ---  227  350
> B 298  ---  252
> C 175  273  ---
>
> Here you can see that the data we're looking for is "C beats A" and
> "A beats C". Since there are only two candidates remaining from the
> first round, the second round will be an one-on-one, which is the
> kind of contest the Condorcet matrix stores information about. If C
> beats A more often than A beats C, C is the winner. Incidentally,
> this shows that the contingent vote passes Condorcet loser.
>
> But let's do it again, with only the summable information about each
> district (that is, the plurality count and the Condorcet matrix).
>
> District 1:
> Plurality count: 100 A, 98 B, 27 C
>
> Condorcet matrix:    A    B    C    beats
>                    A ---   98  125
>                    B 127  ---   27
>                    C 100  198  ---
>
> District 2:
> Plurality count: 50 A, 25 B, 225 C
>
> Condorcet matrix:   A    B    C    beats
>                   A ---  129  225
>                   B 171  ---  225
>                   C  75   75  ---
>
> Let's sum this all up:
> Plurality count: 150 A, 123 B, 252 C
>
> Condorcet matrix:  A    B    C    beats
>                  A ---  227  350
>                  B 298  ---  252
>                  C 175  273  ---
>
> And run the election method again:
> First "round": greatest two are A (150) and C (252)
> So A and C go to the second "round".
> Second "round": A>C by 175, C>A by 350, so C wins.
>
> There you go, the contingent vote is summable.

Not clear why the two districts were even mentioned.

Since Condorcet was mentioned, might make sense to include a cycle and
see how much this complicates life.

As I say above, what qualifies as summable?
>
>>> I'm not sure about IRV - has anyone devised an STV variant that
>>> handles equal rank? If not, then you're right - again, I'm not sure.
>> Brian claims, and I cannot disprove, that IRV can be stretched to
>> tolerate equal rank - questionable whether it would be worth the
>> expense for real elections.
>
> There are two ways to handle equal rank, in theory, for a weighted
> positional method. Plurality is just a weighted positional method
> with the weights (1, 0, 0, ..., 0). The first is "whole", which
> means that if you rank A = B > C, A and B has the same score, which
> is the same as A in A > C. For plurality, that would turn it into
> Approval. The second is "fractional", which means that the sum of
> the score for all ranked candidates in a certain rank is the same,
> no matter how many you ranked. For instance, for Plurality, ranking
> A = B > C would give half a point to A and B (so that the sum is 1),
> and none to C, whereas ranking A > B > C would give a full point to
> A and none to B or C.
>
> Elimination would work the same way however equal rank would be
> treated. If you vote A = B > C and A is eliminated, then for the
> next round, your vote is B > C.
>
> Assuming the voting machines can handle the input, where would the
> expense lie in adding this support? It seems to be more a question
> of whether the resulting system would be "IRV" or not... unless the
> expense would be in "handling the input", but if you have a machine
> that can handle A > B > C > D > E .. > Z, upgrading it to handle A =
> B = C > D > E ... doesn't seem to be that expensive a change.

Huh?  Noticing whether equal ranks exist; including fractions in doing
sums; etc.

Note that for the current discussion Condorcet is simpler - for each
pair of candidates count A>B or B>A if they exist.
>
>>> From what I've seen of voting equipment, most limitations seem to
>>> be in the name of expediency. For instance, SF's RCV three-rank
>>> method keeps voters from ranking more than three candidates -
>>> probably to accomodate existing equipment.
>> I am suspicious as to this relating to existing equipment, but:
>>     Some ways of providing for more ranks significantly burden
>> equipment design.
>>     Providing for 2 ranks is essential to deserve claim as to ranks
>> existing; 3 helps some; more than 3 helps real voters little.
>
> One may then ask, how many ranks are required to break Duverger's
> Law? Unfortunately, I don't know the answer.
>
>>> What limitations may exist (such as your IRV example) may be
>>> handled by having a voting machine that permits all ranking types
>>> (full, truncated, equal rank), then having parameters that limit
>>> according to what kind of voting system is being used in the back
>>> end (e.g no equal rank).
>> Sounds like building in expensive complications.
>> Doing the specialization in software could be affordable.
>
> There's a tradeoff at this point. Having a generalized machine lets
> you build many that are all the same, so that you gain benefits of
> scale. However, the generalized machine is more expensive because
> you can't cut away what you don't need.
>
>>> It is in theory possible to make it summable - see above. The
>>> method they did use seems not to be, though - as far as I could
>>> see, they checked, for all possible virtual runoffs (set by
>>> enforcing A and B as winners in the first round), whether A or B
>>> won. Such a binary check is summable only if the results are the
>>> same in both districts - but when they're different, one runs into
>>> trouble. Consider this, for instance:
>>>
>>> District 1      X>Y: 1000, Y>X:  990    X beats Y
>>> District 2      X>Y:    1, Y>X:    2    Y beats X
>>> -------------------------------------------------
>>> Summed result                           X beats Y
>>>
>>> but also
>>>
>>> District 1      X>Y: 1000, Y>X:  990    X beats Y
>>> District 2      X>Y: 1000, Y>X: 2000    Y beats X
>>> -------------------------------------------------
>>> Summed result                           Y beats X
>>>
>>> In both instances, X beats Y in the first district, and Y beats X
>>> in the second district, but the summed result is different for the
>>> two cases. Thus I think that they would have to store the entire
>>> Condorcet matrix (numbers of voters, not just who won) in order to
>>> be summable. If they did, then they're summable, but if they
>>> didn't, they aren't.
>> Condorcet cares not as to number of voters - for it simply sum the
>> matrices.
>
> If nobody equal-ranks, then (A beats B) + (B beats A) = number of
> voters. Apart from that, you're right, Condorcet doesn't care. What
> I showed was that if they (the IRV proponents) tried to use only
> binary arrays instead of integer arrays for their kinda-Condorcet
> matrices, they would fail, because there's not enough information
> there. A Condorcet matrix has to be integer (or even more fine
> grained, e.g for CWP), even when that matrix is only to be used for
> determining the winner of the contingent vote.

What do you do when some voters vote for neither A nor B?

Not clear to me what a binary array would be.
>
>>> I mean freedom as a data format. A rated vote data format can
>>> emulate a ranked vote format, as well as an approval-style data
>>> format.
>> Saying freedom reminds me of something we sometimes ignore - how
>> much complication do we burden voters with.
>
> Voting is already irrational from a utilitarian point of view - your
> chance of affecting the outcome is way too small for it to be worth
> bothering to vote, let alone consider the issues to make an informed
> decision. Yet we vote anyway.
>
> That muddies the waters, because we can't use standard utilitarian/
> economic theory to find out how much complication is too much.
> Perhaps people wouldn't bother with anything more than Approval, but
> that seems wrong (since people rate and rank things all the time).
> So, how much is too much? I don't know.

Imposing ratings for score is a noticeable complication.

Condorcet can claim a bit of simplification:
Voting as in Plurality should be encouraged whenever that meets
a voter's desires - in many races many voters need nothing more.
Voting as in Approval - ditto.
More complex ranking is really a simplification for those voters
who desire to use that ability, rather than being forced to live with
what Plurality offers.
>
> Of course, the user interface should be good, but that's a separate
> issue. I don't particularly like general purpose direct electronic
> machines, so the "user interface" may be entirely transparent - put
> the appropriate number in the box next to the candidate (for each
> candidate), then at some later time, OCR reads off the numbers to
> parse the ballot.

```