Library · The Fiddler: Solutions · Chapter 82

Can You Play the Favorite?

Revised Report an error

In a four-team region seeded 11 through 44, when an MM-seed plays an NN-seed the MM-seed wins with probability NM+N\tfrac{N}{M+N}. The bracket is 11 vs 44 and 22 vs 33, and the winners meet. What is the probability the 11-seed wins the region?

The Fiddler, Zach Wissner-Gross, March 21, 2025(original post)

Solution

The 11-seed beats the 44-seed with probability 45\tfrac45, then meets the 22-seed (who arrives with probability 35\tfrac35) or the 33-seed (probability 25\tfrac25): P=45(35⋅23+25⋅34)=45⋅710=1425≈56%.P=\frac45\left(\frac35\cdot\frac23+\frac25\cdot\frac34\right) =\frac45\cdot\frac{7}{10}=\frac{14}{25}\approx\boxed{56\%}.

The computation

Encode the bracket: the 11-seed must beat its first opponent, then beat whichever of the 22- and 33-seeds survives, each path weighted by the model’s win probabilities.

from fractions import Fraction as F
beat = lambda m, n: F(n, m + n)             # P(m-seed beats n-seed)
print(beat(1, 4) * (beat(2, 3)*beat(1, 2) + beat(3, 2)*beat(1, 3)))   # 14/25

Extra Credit

As before, an MM-seed beats an NN-seed with probability N/(M+N)N/(M+N). Now a region has 2k2^k teams, where kk is a very large whole number, seeded 11 to 2k2^k and played in the traditional format: in the first round opponents’ seeds add up to 2k+12^k + 1, in the second round they would add up to 2k−1+12^{k-1} + 1 if the stronger team always advanced, and so on. What is the probability that the 11-seed wins the region?

Solution

Fold the bracket up from the bottom. Each slot in each round has a distribution over which seed arrives there; when two slots meet, every pair of possible arrivals plays, and the winner’s distribution follows from the win rule. The first few values are exact fractions: k=1: 23,k=2: 1425,k=3: 225148426465≈0.528,k=4: ≈0.519.\begin{gathered} k = 1:\ \tfrac23,\qquad k = 2:\ \tfrac{14}{25},\\ k = 3:\ \tfrac{225148}{426465} \approx 0.528,\qquad k = 4:\ \approx 0.519 . \end{gathered} The probability falls as kk grows, because the 11-seed has more rounds to survive. The question is where it ends up, and the key observation is that it does not fall to zero, nor to one half, but levels off.

Here is why. The 11-seed’s opponent in the round jj steps before the end comes from a block of the bracket whose favourite is seed 2j−1+12^{j-1} + 1 or so, and in the early rounds of a huge bracket that opponent is almost always one of the block’s strong seeds. Against a seed near mm the 11-seed loses with probability 1/(1+m)1/(1+m), about 1/m1/m. The chances of losing in successive rounds, counting back from the final, are therefore roughly proportional to 12,14,18,…\tfrac12, \tfrac14, \tfrac18, \dots, a sum that stays finite however many rounds are added. Adding an extra early round to a big bracket costs the 11-seed only a sliver, and the slivers shrink geometrically. So the probability tends to a definite limit. The early rounds are nearly free; the final few rounds against seeds 22, 33, 44, 55, … decide it.

That limit has no closed form that I know of, but the exact fold-up converges fast: from k=9k = 9 on, each further round changes the value by less than 0.000010.00001, and from k=11k = 11 on by less than 0.0000010.000001. For a very large region,  P  ≈  0.51543 \boxed{\ P \;\approx\; 0.51543 \ } a little better than a coin toss. (The source’s value is paywalled; this is my own.)

The computation

The fold-up described above, carried out exactly (in floating point) for brackets of up to 214=16,3842^{14} = 16{,}384 teams. The bracket order puts seeds ss and 2k+1−s2^k + 1 - s side by side, recursively, which is the traditional seeding.

import numpy as np

def bracket(k):
    """Seeds in bracket order: neighbours meet in round 1, and so on."""
    o = [1]
    while len(o) < 2**k:
        m = 2*len(o) + 1
        o = [x for s in o for x in (s, m - s)]
    return o

def one_seed_wins(k):
    # each slot: (seeds that can emerge, probability of each)
    slots = [(np.array([s]), np.array([1.0])) for s in bracket(k)]
    while len(slots) > 1:
        nxt = []
        for (s1, p1), (s2, p2) in zip(slots[0::2], slots[1::2]):
            meet = p1[:, None]*p2[None, :]                 # who meets whom
            a, b = s1[:, None], s2[None, :]
            w1 = (meet*b/(a + b)).sum(axis=1)              # M beats N w.p. N/(M+N)
            w2 = (meet*a/(a + b)).sum(axis=0)
            nxt.append((np.concatenate([s1, s2]), np.concatenate([w1, w2])))
        slots = nxt
    seeds, probs = slots[0]
    return probs[seeds == 1][0]

for k in (2, 4, 6, 8, 10, 12, 14):
    print("k = %2d: %.7f" % (k, one_seed_wins(k)))

It prints

k =  2: 0.5600000
k =  4: 0.5192184
k =  6: 0.5158337
k =  8: 0.5154592
k = 10: 0.5154323
k = 12: 0.5154313
k = 14: 0.5154314

The values settle at 0.515430.51543; the last digit wobbles only through rounding in the floating-point sums.

Report an error on this page

Reports are stored by Netlify. See the privacy note.