Why Nobody Uses $10 Bills

Using Math to find Optimal Currency Denominations

Alexander Hamilton is on the $10 bill, and fittingly so. As the first Treasury Secretary, he created a national bank of the United States to stabilize the fledgling country’s finances by absorbing states’ war debts. While Washington is always #1, Hamilton is emblazoned on the $10, a presumably important order of magnitude.

Ironically, Andrew Jackson on the $20 bill sees far more circulation today. Jackson was a populist anti-establishment politician who opposed the centralized power and foreign investors in the national bank. He effectively broke the bank by vetoing its charter and withdrawing federal funds. This bank war ultimately led to financial instability and the economic panic of 1837. Despite all that, the Jackson $20 is the third-most common banknote (after Franklin's $100 and Washington’s $1), and the second-most in value. Hamilton is second-last, only beating out the $2.

Source: https://www.federalreserve.gov/paymentsystems/files/coin_currcircvolume.txt

USD functionally runs on the subset of $1, $5, $20, and $100 notes, with poor Hamilton left out in the middle. This isn’t just happenstance; this subset of bills is actually a mathematically optimal set of denominations. Let me explain.

Optimal Denominations

The ideal set of banknote denominations should optimize for:

1. Load: Fewer notes needed to represent a particular value.

2. Variety: Fewer unique values are easier to produce and handle.

3. Ease of Use: Easy mental math and physical handling.

Let’s go through these in order.

Load is Minimized with Exponential Spacing

Suppose we have a fixed number of distinct banknote values. We need a $1 note, we want a $100 note, and we are willing to have N values in-between. As it turns out, the optimal values are spaced exponentially.

Consider the case of N=1: we want to pick a single value between $1 and $100. How many notes does it take to have $X? In the chart below, we plot the notes required (Y-axis) for a particular dollar amount (X-axis), with summary stats on the right. Consider three sets of banknotes:

• Jeff: {$1, $5, $100}

• Ham: {$1, $10, $100}

• Jack: {$1, $20, $100}

Hamilton (blue) is the winner! Though each set over- or under-performs in particular ranges, the $10 set does best here. This is because 10 = sqrt(100) is halfway between the anchor points of $1 and $100 on an exponential scale.

If we up it to N=2, this changes. The cube root of 100 is an irrational between 4 and 5, but we can approximate it as 100 = 5 x 4 x 5. This yields our familiar notes of $5 and $20.

Again, we can plot the load for different note sets

• Jeff+Jack: {$1, $5, $20, $100}

• Jeff+Ham: {$1, $5, $10, $100}

• Ham+Jack: {$1, $10, $20, $100}

• Coins: {1¢, 5¢, 25¢, 100¢}

• Low: {$1, $2, $5, $100}

• High: {$1, $20, $50, $100}

As predicted, Jeff+Jack (yellow) is the winner! Exponential spacing performs best. Note that the alternative exponential spacing used in coins (1¢, 5¢, 25¢, 100¢) performs identically to the bills.

Variety-Load Tradeoff

Thanks to the above, we know how to minimize load (number of banknotes needed) given a particular variety (unique banknote denominations). This begs the question: how much do we prioritize load vs. variety?

Benchmarking to $100, we can choose to break it into N steps based on the Nth root of 100, and spacing the K-th denomination at 100^(K/N):

• 1 step: {$1, $100}

• 2 steps: {$1, $10, $100}

• 3 steps: {$1, $5, $20, $100}

• 4 steps: {$1, $3, $10, $30, $100}

• 5 steps: {$1, $3, $6, $15, $40, $100}

• 6 steps: {$1, $2, $5, $10, $20, $50, $100}

(Note: N here is different than the previous section)

Adding any intermediate steps is a massive improvement over the base case of {$1, $100}. But there are diminishing returns: the 5-step and 6-step case actually have the same aggregate metrics. As the currency designer, you’re basically choosing between 2-5 steps.

Ease of Use – Divisibility and Physicality

You may have noticed the 5-step {$1, $3, $6, $15, $40, $100} has very awkward numbers. Ultimately, we are designing for humans, so let’s make some human considerations.

Mental Math. It’s easier to do math in 10s, 5s, and 2s. We have 5 fingers and 2 hands, after all.

Greedy Algorithms. Intuitively, you would probably count out currency amounts by using the largest quantities first. For example, to dole out $24, you would first take a $20, and then four $1s. However, this algorithm isn’t optimal for all banknote sets.

Consider the “High: {$1, $20, $50, $100}” set used earlier. If we wanted to dole out $110, you might intuitively do one $100 and ten $1s, for a total of eleven notes. However, it’s actually lighter to do one $50 and three $20s, totaling four notes. I believe this occurs if the least common divisor of some values is not part of the set (in this case, LCD($20, $50) = $10, but $10 is not present). In any case, we want the simple greedy algorithm to be optimal, rather than a complex dynamic programming problem.

Divisibility. Ideally, each incremental bank note is divisible by the previous one. This makes breaking one $20 into four $5s easy. This serendipitously satisfies the greedy algorithm issue above.

Physicality. Real-world physical constraints also come into play.

For example, standard North American cash registers have 5 slots. These are usually reserved for $1, $5, $10, $20, and “Other” (large bills and checks). Notably, $2 is absent, which may explain the scarcity of $2 bills in common transactions.

Paper bills are relatively easy to handle. However, for clunkier objects like board game pieces, it may be preferable to reduce load by increasing variety.

Takeaways

As a physical currency designer, you should pick from one of these sets:

• 2 steps: {$1, $10, $100}

• 3 steps: {$1, $5, $20, $100}

• 4 steps: {$1, $3, $10, $30, $100}

The US currency system could afford to kill the $2, $5, and $50 bills without much harm. For physically clunky systems like board game pieces, consider the {1, 3, 10, 30, 100} system.