I’ve been thinking about how to push ranked choice voting for Taiwan and one push back is that many people in Taiwan feel it’s too complicated, and they don’t trust machines counting their ballots.

The goal of ranked choice voting is obviously promote a multi-party system, build on consensus, and end partisanship and divisiveness.

But if the people want the votes to be counted one at a time by 2 officials and allow an audience that can verify the process, going through elimination rounds over and over again is simply way too painful for these “officials” who are nothing more than teachers forced to work on weekends.

So what do we do?

My first thought is do something frequently done in computer science to improve program efficiency, loop unrolling. Instead of having the computer go through the iterations at run-time, waiting until hitting a branch point to know what to do, just flatten the loop out so the compiler and other resource schedulers on the computer know what’s coming and can plan ahead of time.

So instead of

int x;

for (x = 0; x < 3; x++) {

print(x);

}

Just do

int x = 0;

print(x);

x++;

print(x);

x++;

print(x);

The problem is, if you have 10 candidates running, the voters can rank them from one to ten and you want to unroll that, that’s a permutation of p(n, k), where n is 10 and k is 10.

That’s n!/(n-k)! which would be 10! and you would have 3,628,800 different ways to cast your vote. That isn’t going to help at all with reducing workload.

The only way to get the number of permutations down to a manageable size is by limiting the number of candidates that can be on a ballot, and the number of ranks you are allowed to give them.

The only number that seems to be manageable is 5 candidates, and you are only allowed to rank from 1st preference to 2nd preference. That would give you p(5,2), which is 5!/3! and leaves you with 20 permutations for allowed votes.

At this point you could count the votes by putting down all 20 permutations on a board.

A. 12

B. 13

C. 14

D. 15

E. 21

F. 23

G. 24

H. 25

I. 31

J. 32

K. 34

L. 35

M. 41

N. 42

O. 43

P. 45

Q. 51

R. 52

S. 53

T. 54

Then you can begin tallying the votes. An imaginary ballot would look like this:

This particular ballot would be 32, so the first official will call 32, and the second official will call 32, and the third official will add one to J. 32.

By the time all the ballots are counted, and it is obvious no one surpassed 50% in the first round, then it’s extremely easy to figure out who has the least votes in the first run (radix sort). After eliminating that candidate, it is also extrememly easy to figure out who those votes should go to next.

By limiting your ranking options down to 2, you are essentially allowed to pick your favorite candidate, and choose one safety option.

The only down side is you have to come up with a way to limit the numbers of candidates down to just 5.