21 - Voting Systems & Arrow's Theorem
Arrow’s Impossibility Theorem
I’m presenting the simplified version today. There’s a lot of other complicated social sciences stuff to consider here too.
Also, it’s somewhat visual, take a look at the show notes if you can, hopefully this won’t be a flop.
If literally everyone’s vote indicates that they prefer Rust over Scala, then in the final results, Rust should be ranked higher than Scala
Independence of irrelevant alternatives
If people prefer Rust over Scala, removing or changing your ranking of Ruby should not affect the outcome of Rust compared to Scala.
Arrow demonstrated the surprising result that a ranked voting system with these two desirable properties must be a dictatorship: one person alone has the power to determine the entire outcome of the election.
Let’s say we have the following configuration
Everyone prefers Rust to Scala. Because of Unanimity, the final results must place Rust above Scala in group preference.
Now let’s everyone changes their mind and changes their preference of Scala higher than rust. Because of Unanimity, the final results must place Scala above Rust in group preference
So we know that at some specific point, the result flipped. In this case, if we did it one at a time, we would see that Bob’s vote changed it. Bob is pivotal.
Let’s look at this situation:
At this point, because Bob is still pivotal, the final group results indicate that Scala > Rust. Also, Rust > Python by unanimity. So Scala > Rust > Python
Let’s have Bob swap Scala for Rust
Because Bob is the pivot: Rust > Scala Because the order of Python relative to Scala hasn’t changed, because of the independence of irrelevant alternatives: Scala > Python So Rust > Scala > Python
Now, let’s have everyone except Bob swap Python for Rust
Because of the independence of irrelevant alternatives, we know that Scala > Python, since the relative ranks still matches the previous vote. Rust > Scala for the same reason
But now look what happened! We now have a situation where our rules dictated that Rust wins, but Bob is literally the only person who prefers that outcome: Everyone else thinks Python should beat Rust. This makes Bob a dictator that Rust > Python
So to summarize up until now, by following our rules: Bob is the pivot that made Rust > Scala Bob is the dictator that Rust > Python
Now, we’ll go to show that Bob is ALWAYS the pivot in every scenario.
Let’s redo this entire thing but:
Who is pivotal in Rust beating Python? Bob or Alice, or Bob or Charlie. Who is pivotal in Python beating Rust? Bob or Charlie, or Bob or Alice. == Bob is the only person who can be the pivot for Rust > Python or Python > Rust.
So before we only know that Bob was the pivot that made Rust > Scala, but we know that in every situation Bob is the pivot, so bob is also the dictator in that scenario, making him the dictator in all scenarios within our system which contained the rules of unanimity and independence of irrelevant alternatives. This is a scenario which always exist in every system, so there is no ranked voting system that is not susceptible to a dictatorship.
Practically, we know that we don’t want a dictatorship, so we need to choose whether we want unanimity or independence of irrelevant alternatives, which leads to all the voting systems we discussed in the previous episode