Why plurality voting sabotages democracy (and how to fix it)

Imagine a democracy in which most people were good, honest, and intelligent--the kind of people who would use their votes to benefit the nation,

...and only a minority of people were gullible, selfish, or evil--the kind of people who would use their votes to harm the nation.

Since democracy lets the majority rule, this would be a pretty great nation to live in, right?

Well, yes, as long as the nation didn't use plurality voting. (Plurality voting is where each citizen is allowed to vote for exactly one candidate. It's the kind of election system we use in the United States.) And what exactly is wrong with plurality voting?

Since there are more good people, there are usually more good candidates. Moreover, we encourage really good people to run for office. We try very hard to make sure there are more good candidates than bad ones.

So let's imagine there are two good candidates, and one corrupt one:
Candidate A campaigns on a platform of family values, better education, and scientific research.
Candidate B campaigns on a platform of lower taxes, less government overreach, and a strong economy.
Candidate C campaigns on a platform of handouts for his supporters, jail for the opposition, and death to the "wrong kind of people".

...and then an election happens:
Votes for Candidate A: (35%)

Votes for Candidate B: (25%)

Votes for Candidate C: (40%)

Gasp! How did the most obviously evil candidate manage to upset the election and seize power in a democratic nation of predominantly good people!? Have the people turned evil? No. That's just what plurality voting does. Plurality voting sabotages democracy.

Since the gullible, selfish, and evil people usually have fewer choices, they all end up banding together to give the worst candidate undeserved support. That shouldn't happen in a healthy democracy. So let's discuss two good solutions and one bad solution to this problem:

Good solution #1: Approval voting

Approval voting lets citizens vote for or against each candidate. Here is a comparison of what the ballots would look like:

Why does approval voting solve the problem? Because when you can vote for whomever you really want, you vote for whomever you really want. Note that candidates A and B would both get the most votes with approval voting (as they should, since most people in this democracy prefer them).

With plurality voting, people don't really vote for who they want. Why not? Because voting for who you really want is throwing away your vote. People are smart enough to only vote for candidates with a real chance of winning. And when no one votes for who they really want, the candidates people really want do not get elected.

Good solution #2: Run-off voting

In a run-off, there are multiple elections. After each election, the candidate with the fewest votes is eliminated. And elections continue until only one candidate remains.

Why does run-off voting solve the problem? Because in a run-off, when third-party candidates split the vote, the voters just come back together again in the next election after the weakest candidate is removed. It doesn't destroy the authority of the majority. Thus, there is no value in leaning toward candidates with a better chance of winning, so people actually vote for whom they really want.

Isn't our system, where we first have primary elections followed by a general election sort of like a small run-off? Short answer: No. Unfortunately, in the United States primary elections are closed to exclude non-party members.

(Longer answer: If the primaries were really open, then the issue of whether we wanted a liberal or a conservative candidate would be settled in the primary election. Then, the next round would be about settling the second principal component of the will of the people. And the more rounds of elections, the more components the people would be able to express. As it is, however, we just keep voting about the same issue--liberal/conservative--over and over and over. Consequently, that component actually is in the hands of the people in this nation. But who controls all the other orthogonal components? Hint: Not the people.)

And isn't it cumbersome to have so many elections? Yes. That's why instant run-off voting was invented. In instant run-off voting, each citizen ranks the candidates. Then, the rankings are used to determine who would have won if a full run-off election had been held.

Bad solution: Two-party system

What happens if no one ever addresses this problem and a democracy just keeps using plurality voting, like in the United States? Well, smart people recognize that their vote in this broken system will have far more impact if they choose one of the two most-probable candidates. They also try to extend their influence by advising others not to waste their votes on third-party candidates. So the more intelligently people behave, the more two powerful parties naturally form. Then, in every election, almost everyone is stuck voting for whomever they think is the lesser of the two evils.

Why does this fix the problem? Simple. As long as there are no viable third party candidates, there is no one to split the votes.

Why is this such a terrible solution? There is a big cost for this solution. This cost is at least two-fold:

First, most people don't vote for whom they really want in a two-party system. Since everyone knows only the representatives of the two dominant parties really have a chance of winning, they become the only two options. Did you vote for a person you really wanted? Of course you didn't. You voted for one of the two viable candidates who bothered you the least. That's what almost everyone does.

A democracy cannot be led by the will of the people if the people do not even express who they really want. How could it be led by the people? How would it even know what the people want if they never say? Think about that for just a minute. Who really holds the power in this nation?

Second, a two-party system creates two powerful parties. Of course, that's much better than having just one powerful party. But when the two parties both start pushing in a correlated direction, there becomes no way for the people to vote against that direction. And as the two parties become more powerful, they start using their power to secure more power. So instead of one corrupt monarch, we have two corrupt pseudo-monarchs that fight each other. C'mon. We can do better than that.

So, what can we do about this?

Can we just fix our election system? Unfortunately, no. Most people don't see anything wrong with plurality voting. And that's an even bigger problem! Ironically, people will fight to defend a broken system because they fear solutions they don't understand. It's good to fear things we don't understand. But it's not good to be ignorant.

Like most big problems, this one requires a long-term solution. The best way to kill plurality voting is to help people understand it. You can teach your kids how alternative voting methods work. You can point them in the direction of game theory. If you don't know what that is, maybe find something to read about it. Then maybe there will be democracies in the future that really give power to the people.

But wait a second, you might say, people are dumb. Do we really want the common people to have more control? That's a valid concern. However, people will always have control. If you don't give power to the common people, it inevitably falls into the hands of people who seek for power. And those people are even worse! Sure, the common people will certainly make some bad decisions. But maybe they can learn from their mistakes. Let's give the next generation a chance to build a better democracy. No, they won't do a perfect job. But in the long run, making mistakes is the path to greatness ...if you can learn from them.

Simulation

To empirically validate this, I wrote a simulator in Python that generates random populations with random opinions about a set of hypothetical candidates. I simulated 1000 elections, computed the winner using three different voting schemes. My results indicate that approval voting is the most effective of the three voting methods at picking a winner that the most people will have a positive opinion about, and plurality voting is the least effective. Here's my code so you can try it yourself or check my work:

import random
import numpy as np

def contentment(opinions: np.array, winner: int) -> float:
    return float(np.sum(np.clip(opinions[:, winner] * 1000.0, -1., 1.))) / int(opinions.shape[0])

def plurality_voting(opinions: np.array) -> float:
    tally = np.zeros(opinions.shape[1])
    for i in range(opinions.shape[0]):
        choice = np.argmax(opinions[i])
        tally[choice] += 1
    winner = np.argmax(tally)
    return contentment(opinions, winner)

def approval_voting(opinions: np.array) -> float:
    tally = np.zeros(opinions.shape[1])
    for i in range(opinions.shape[0]):
        for j in range(opinions.shape[1]):
            if opinions[i, j] >= 0:
                tally[j] += 1
    winner = np.argmax(tally)
    return contentment(opinions, winner)

def ranked_choice(opinions: np.array) -> float:
    candidates = np.arange(opinions.shape[1])
    while len(candidates) > 1:
        ranks = np.empty((opinions.shape[0], len(candidates)))
        for i in range(opinions.shape[0]):
            ranks[i] = np.argsort(np.argsort(-1. * opinions[i, candidates]))
        tally = np.sum(ranks, axis = 0)
        loser_index = np.argmax(tally)
        candidates = np.concatenate([candidates[:loser_index], candidates[loser_index + 1:]])
    winner = candidates[0]
    return contentment(opinions, winner)

def simulate_elections() -> None:
    plurality_sum = 0.
    approval_sum = 0.
    ranked_sum = 0.
    trials = 1000
    for i in range(trials):
        # Each row represents a citizen
        # Each column represents a candidate
        # Each element represents how much the citizen likes the candidate
        opinions = np.random.uniform(-1.0, 1.0, (random.randrange(50, 200), random.randrange(3, 8)))
        plurality_sum += plurality_voting(opinions)
        approval_sum += approval_voting(opinions)
        ranked_sum += ranked_choice(opinions)
    print('    Plurality voting contentment = ' + str(plurality_sum / trials))
    print('     Approval voting contentment = ' + str(approval_sum / trials))
    print('Ranked choice voting contentment = ' + str(ranked_sum / trials))

simulate_elections()

Related content