The Overhand Shuffle Depends on Your Thumb

2026-10-07 · Kit Wickham

Everyone who's read about card shuffling knows two numbers: seven riffle shuffles mix a deck, and the overhand shuffle (sliding small packets off the top of the deck from one hand into the other) takes thousands. The figure usually quoted is 2,500, sometimes 10,000.

I wanted to see the overhand curve for myself, so I simulated it. The answer depends mostly on one thing the quoted figure leaves out: how many cards your thumb slides off at a time. With packets of about six cards, a 52-card deck is as mixed as seven riffles leave it after roughly 25 shuffles, and close to random after 40. With packets of two cards it takes 400 to 500. Getting there also meant catching my own tests being blind.

The model

I used the standard mathematical model of the overhand shuffle, introduced by Robin Pemantle in 1989. Each of the 51 gaps between adjacent cards is independently a cut with probability p. That splits the deck into packets with an average of about 1/p cards, and the packets are stacked in reverse order, top packet at the bottom, with each packet keeping its own order. Pemantle proved that for a deck of n cards the number of shuffles needed grows somewhere between n² and n² log n. Johan Jonasson showed in 2006 that n² log n is the right answer. Neither result gives a number for 52 cards.

The usual way to measure "mixed" is total variation distance: the largest difference, over every possible event, between the chance it happens with the shuffled deck and with a perfectly random one. 1 means the deck is completely predictable, 0 means perfectly random. Seven riffles leave a 52-card deck at 0.33. To get below 0.1 takes nine.

For 52 cards you can't compute this exactly, because there are 8 × 10⁶⁷ possible orders. What you can do is pick features of the deck (where each card ends up, how many cards still sit next to their original neighbour, how many pairs are out of order) and measure the distance for those. Any feature gives a lower bound: if the feature isn't random yet, the deck isn't either. Whether the bound is close to the truth depends on whether you picked the right features.

I checked the setup on the riffle shuffle first, where Bayer and Diaconis's exact formula exists. One feature, the number of "rising sequences", carries all of the riffle's non-randomness, and the simulated distance matched the exact formula to three decimals at every shuffle count I checked from 1 to 14 (0.334 at seven).

The answer

Left: distance from a random deck against number of shuffles on a log scale, 52 cards starting sorted. The exact riffle curve drops from 1 to below 0.1 between 5 and 9 shuffles. Overhand shuffles with average packet sizes 6, 10, 4, 20 and 2 cards drop below 0.1 at about 40, 50, 80, 120 and 500 shuffles. Right: 9 cards with 2-card packets. The exact distance falls from 1 to about 0.13 at 10 shuffles. The inversion count tracks it closely after the first few shuffles; the worst single card's position sits about half as high. — Left: largest distance over all the features I measured, 200,000 simulated decks per curve, noise floor about 0.01; riffle is exact. Dotted line at 0.1. Right: 9 cards, where every one of the 362,880 orders can be tracked exactly.

average packet	cuts per shuffle	distance below 0.25	below 0.1
2 cards	25	301–400	401–500
4 cards	13	51–60	71–80
6 cards	about 8	21–25	31–40
10 cards	5	31–40	41–50
20 cards	2–3	81–100	101–120
riffle (exact)		8	9

Ranges are between the two shuffle counts I sampled. Small and large packets are both slow, for different reasons.

Small packets barely mix. With two-card packets, one overhand shuffle is close to turning the deck upside down, and two shuffles mostly undo each other. Each card drifts a few places per shuffle, and the deck's overall order fades slowly while it flips back and forth. The feature that's still non-random longest is the count of out-of-order pairs, which is the slow mode.

Large packets keep neighbours together. Two cards that start next to each other stay together until a cut lands between them, and with 20-card packets that happens to a given pair only one shuffle in 20. Breaking up all 51 original neighbour pairs takes about ln 51 / p shuffles, which is 77 at p = 1/20 and 37 at p = 1/10. Here the slowest feature is how many cards still sit right after their original neighbour.

Around six cards per packet, neither effect lasts long, and that's the fastest overhand shuffle I found.

My first tests were blind

My first set of features said two-card packets were done by 400. The trouble with lower bounds is that they never tell you what you didn't measure, so I checked them against the exact answer on small decks. With 9 cards there are 362,880 orders, few enough to track the exact probability of every one shuffle by shuffle.

For six- and four-card packets, the features matched the exact distance within one shuffle at every deck size from 5 to 9 cards. For two-card packets they didn't, and the gap grew with the deck: at 8 cards my features said 0.1 was reached at 7 shuffles when the truth was 10. Breaking the exact distribution down showed where the missing distance was. After 10 shuffles of 9 cards the true distance is 0.135. The worst single card's position accounts for 0.071, triples of cards 0.113, and the number of out-of-order pairs 0.130 on its own (the right panel).

I had a feature close to that, a rank correlation, but I'd taken its absolute value to cancel out the flipping. That threw away which way up the deck was, which is exactly what the slow mode remembers. After adding the out-of-order count, the features matched the exact answer within one shuffle at every size from 5 to 9 cards for all three packet sizes I tested, and at 52 cards two-card packets moved from 301–400 shuffles to 401–500.

Where 2,500 comes from

I couldn't trace the popular figure to a calculation. It's close to 52² = 2,704, and 10,000 is close to 52² × ln 52 ≈ 10,700, so they look like the theory's growth rates with the constant set to one. The constant isn't one, and it depends on packet size. Pemantle's paper is also quoted as reporting simulations where 1,000 or more shuffles were needed in many situations. I haven't read his simulation setup, but my two-card result is in that range if you ask for a distance well under 0.1 (600 to 700 shuffles for 0.03).

The growth rate itself checks out. With two-card packets, the shuffles needed to get below 0.1 went from 21–25 at 13 cards to 101–120 at 26, 401–500 at 52 and 2,001–2,500 at 104: roughly four to five times per doubling, as n² log n predicts. With six-card packets it's 21–25 at both 13 and 26 cards (the neighbour-pair effect dominates small decks), then 31–40 at 52 and 121–150 at 104. Fifty-two cards is about where the n² behaviour starts to take over.

An overhand shuffle with packets of around six cards gets a sorted 52-card deck to where seven riffles do in about 25 shuffles, and close to random in about 40. That's four or five times as many shuffles as riffling, but not 2,500.
Tiny packets are the worst case: 400 to 500 shuffles. Huge packets are bad too, because neighbours stay together.
A lower bound from features is only as good as the features. Check them against an exact answer where you can, and don't fold away a sign you think doesn't matter.

Limits: this is Pemantle's model, where every gap is cut independently with the same probability. Real hands don't cut uniformly, and they vary from shuffle to shuffle. My 52-card numbers are lower bounds from nine whole-deck features plus every card's position; I've only confirmed they're tight up to 9 cards. Decks start sorted here. A deck that comes out of a game is already partly mixed, but in a structured way, and I didn't test that.