Chapter 144
Bingo Cards and the Empty Supreme Court
The Riddler for April 14, 2017. The Express counts standard American bingo cards: each column draws from a disjoint pool of numbers, with a free centre square. The Classic asks for the expected number of vacancies on a nine-seat Supreme Court when justices’ tenures are uniform on years and seats can only be filled when the same party controls the presidency and the Senate.
Riddler Express
A standard American bingo card is a grid. The five columns are labelled B, I, N, G, O. Column B contains five distinct numbers from , column I five distinct numbers from , and so on through column O drawing from . The centre square (column N, row 3) is a “free space” and carries no number. How many distinct bingo cards are there?
The Riddler, FiveThirtyEight, April 14, 2017(original post)
Solution
The columns are independent: the pool for each column is disjoint from the others, so filling one column places no constraint on another. Two cards are different if any cell differs. Within column B, we choose an ordered -tuple of distinct numbers from (order matters because row positions are part of the card’s identity). That count is the falling factorial The columns I, G and O give the same count. Column N is identical except for the free centre square, so it places only four numbers, with count Multiplying: The exact value is
The computation
Encode the rule directly: factor each column’s count from the disjoint pool, with the centre square skipped in column N, and multiply.
from math import prod
def falling(n, k):
return prod(range(n - k + 1, n + 1))
cols_BIGO = falling(15, 5) # 15*14*13*12*11
col_N = falling(15, 4) # 15*14*13*12 (free centre)
total = cols_BIGO**4 * col_N
print(f"B,I,G,O column count = {cols_BIGO}")
print(f"N column count = {col_N}")
print(f"total bingo cards = {total}")
print(f"approx = {total:.3e}")
# B,I,G,O column count = 360360
# N column count = 32760
# total bingo cards = 552446474061128648601600000
# approx = 5.524e+26
Riddler Classic
The Supreme Court has nine seats. At the start of time the bench is empty. Each election, each party has an independent chance of winning the presidency and an independent chance of winning the Senate, so the government is “aligned” (same party in both branches) with probability . Elections occur every two years. A vacancy can only be filled in an election cycle when the government is aligned; otherwise the seat waits for the next election. Each appointed justice serves a tenure drawn uniformly from years, independently of everything else. What is the expected number of vacancies on the bench in the long run? Extra credit: an open “coolest extension” prize.
The Riddler, FiveThirtyEight, April 14, 2017(original post)
Solution
Each of the nine seats behaves identically and independently in expectation. By linearity of expectation the long-run vacancy count is where is the long-run probability that a single seat is vacant.
One-seat picture. A seat alternates between two phases: filled (a justice serves a tenure , with years) and vacant (waiting for an aligned election). The fraction of time the seat is vacant equals the ratio of expected vacant time to expected cycle time (one filled phase plus one vacant phase): where is the wait from the moment of vacancy to the next aligned election.
Computing (the simple approximation). At the moment of vacancy, treat the government’s alignment as a fair coin (this is the standard simplification). With probability it is aligned and the seat is filled at the next election cycle; treat that as wait (the post does so). With probability the government is misaligned, and the seat waits for the next aligned election. Since congressional elections occur every two years and alignment at each election is an independent fair coin, the number of additional elections waited is geometric with mean (one initial misalignment plus an expected one more election before alignment). Each election is two years apart. Conditioning on the first sub-case (aligned at the moment of vacancy) wait is ; conditioning on the second (misaligned), the wait is the time to the next election, on average year, plus a further geometric tail of expected years (an extra election with probability , geometric mean years on average). So and Hence and
The refinement. The assumption that the government is misaligned with probability at the moment of vacancy is not quite right: a justice’s tenure begins in an aligned government, and short tenures end in a still-aligned government (no election having intervened). After accounting for this bias toward alignment at the moment of vacancy, Hector Pefo’s careful integration gives .
The headline answer:
Extra credit
The 2017 post offered a “coolest extension” prize for variations: correlated election outcomes, different tenure distributions, different court sizes. The qualitative finding from solvers (notably Conor Smith’s extension) was that if presidential and Senate outcomes are positively correlated, the expected vacancies drop, settling around when the two are perfectly correlated. The mechanism is direct: stronger correlation raises the chance of alignment at each election from toward , shortening the wait .
The computation
Encode the process itself: simulate over a long horizon. At each event time (next election, or next seat vacancy), advance the state, flip a new alignment if the event is an election, and fill all vacant seats with new tenures if aligned. Record the fraction of time the bench has each number of vacancies.
Maintain remaining-tenure timers for each of seats; a seat is vacant when its timer is .
Maintain a clock until the next election (-year cadence) and a current alignment bit.
Advance to the next event (election or seat vacancy), accumulating .
At elections, flip alignment; if aligned, fill every vacant seat with a fresh tenure.
import random
def simulate(T=200_000, burn=20_000, seed=0, N=9):
rng = random.Random(seed)
tenures = [0.0] * N # all seats start empty
aligned = rng.random() < 0.5
time = 0.0
total_vac_time = 0.0
counted_time = 0.0
while time < T:
# advance through one 2-year cycle; alignment is constant within it.
t_end = time + 2.0
cur = time
while cur < t_end:
positives = [t for t in tenures if t > 0]
step = min(min(positives), t_end - cur) if positives else t_end - cur
vac_now = sum(1 for t in tenures if t <= 0)
if cur >= burn:
total_vac_time += step * vac_now
counted_time += step
for i in range(N):
if tenures[i] > 0:
tenures[i] -= step
if tenures[i] < 1e-12: tenures[i] = 0.0
cur += step
# mid-cycle: if aligned, fill any seat that just became vacant
if aligned and cur < t_end - 1e-12:
for i in range(N):
if tenures[i] <= 0:
tenures[i] = rng.uniform(0, 40)
# election: new alignment; if aligned now, fill any still-vacant seat
aligned = rng.random() < 0.5
if aligned:
for i in range(N):
if tenures[i] <= 0:
tenures[i] = rng.uniform(0, 40)
time = t_end
return total_vac_time / counted_time
print(f"empirical E[vacancies] = {simulate():.3f}")
# empirical E[vacancies] = 0.612
The simulation reports about vacancies, agreeing with Hector Pefo’s refined and within range of the simple analytic estimate ().