# Is a Shuffle Really Random? Randomness in Bracket Draws

Learn how a shuffle produces randomness in bracket draws, why bias and entropy sources matter, and how to check a draw for fairness.

A shuffle is only as random as the method behind it, so a bracket draw built on a properly implemented Fisher-Yates shuffle can be genuinely fair, while a careless one can carry hidden bias. The Fisher-Yates shuffle walks through the list and swaps each item with one drawn uniformly from the items not yet placed. That structure gives every possible ordering the same chance when the draws are unbiased. Randomness in bracket draws therefore depends on the generator and the entropy source that seeds it, not on the appearance of the result. 

## What the Fisher-Yates shuffle actually does 

The Fisher-Yates shuffle processes a list from one end and exchanges each position with a position picked uniformly from the remaining entries. Working in place means every ordering of the list can appear, and each arrives with equal probability when the picks are unbiased. The shuffle is not a mix of clever swaps, because a poorly chosen swap pattern can skew the outcome. A correct implementation produces a fair random draw for bracket pairings and seeding. 

## Where shuffle bias sneaks into the draw 

Shuffle bias appears when a shuffle does not give every ordering the same chance, and small coding shortcuts are the typical cause. For example, swapping each item with any item in the whole list rather than the remaining part distorts the distribution of outcomes. A pseudo-random number generator with a short cycle or a flawed mapping to indices adds further bias. Checking the algorithm against known results is part of randomness testing before a draw is used for a tournament. 

## Entropy sources and seeding a fair draw 

A pseudo-random number generator is deterministic software that produces a long sequence from an initial seed, so the seed carries the real surprise. An entropy source supplies that seed from an unpredictable physical measurement, and a weak source makes the sequence predictable to anyone who knows the seed. Tournament organizers should keep the seed and the draw record together so a result can be verified later. A fair random draw treats the generator and its seeding as one system. 

## Questions about randomness in bracket draws 

### Is a shuffle really random? 

A shuffle is truly random only when the algorithm and its random number source are both unbiased. The Fisher-Yates shuffle gives every ordering an equal chance when each pick is uniform over the remaining items. Software alone cannot create surprise, so the entropy source that seeds the generator carries the unpredictability. A correct shuffle on a solid seed is a fair random draw for bracket pairings. 

### Why does shuffle bias happen? 

Shuffle bias happens when a shuffle method gives some orderings a different chance from others. Choosing a swap partner from the entire list instead of the unplaced part is one source of skew. A pseudo-random number generator with repeating output also bends the distribution. Comparing outcomes across many test runs is how randomness testing exposes that bias before a draw counts. 

### Does the random number generator matter for a bracket draw? 

The random number generator matters because the shuffle depends on its picks to choose swap positions. A pseudo-random number generator follows a fixed sequence from its seed, so the seed and the generator quality decide how hard the result is to predict. Using a verified generator and recording its seed lets others replay the draw. That record turns the pairing into a verifiable fair draw. 

### How can I check that a draw was fair? 

You can check a draw by replaying the shuffle from the recorded seed and confirming the same order appears. If the software exposes its generator and seed, anyone can repeat the process and compare results. Randomness testing on many runs also shows whether some positions land together more than chance allows. Keeping the seed and the final bracket together makes later checks possible.
