Show notes

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

Alice Bob Charlie
Rust Rust Rust
Scala Scala Scala
Python Python Python

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:

Alice Bob Charlie
Rust Scala Scala
Python Rust Rust
Scala Python Python

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

Alice Bob Charlie
Rust Rust Scala
Python Scala Rust
Scala Python Python

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

Alice Bob Charlie
Python Rust Scala
Rust Scala Python
Scala Python 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:

Alice Bob Charlie
Rust Rust Rust
Python Python Python
Scala Scala Scala

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