Normally shuffling is not much of a problem in 60-card Magic formats because you can typically hold all of the cards in a deck in your hands for an efficient shuffle. This is not the case for cube. Instead you must shuffle the cube in sections and somehow recombine the shuffled sections. The typical method is to randomly distribute the cube amongst shufflers, who then shuffle and randomly pass subsections to other shufflers. The heuristic is generally that passing cards to other shufflers is more important than getting a "thorough" shuffle of any individual section. Over time, this method will lead to a shuffled cube. This is not a very rigorous approach, and shuffle efficiency can be greatly improved by adhering to a strict shuffling algorithm.

Shuffling cubes efficiently and well is essential for running an event such as CubeCon. There have been reports of severely undershuffled cubes in round 1 when cubes are starting in sorted states, despite the adoption of the "shuffle, pass half left" method (aka the "CubeCon method"). I decided to visually analyze the performance of this shuffling method, and found some other shuffling methods that perform much better.

Note: often cube designers will impose some collation rules when shuffling their cubes. For the purposes of this analysis I ignored this; these methods are instead only looking for uniform distributions since that is the desired shuffling goal for most cubes.

The Graphs

The graph on the left shows the probability distribution of card locations in the cube after some iterations of various shuffling algorithms. The X-axis encodes position in the cube, the Y-axis encodes card index (each card in the cube is assigned a number 1-N). Each colorful region corresponds to a particular shuffler, and the dark shading is proportional to the probability that card Y is in position X (normalized for visual clarity). When in the initial sorted state, each card Y is in position Y in the cube; the probability that card Y is in slot Y is 1, and the probability that card Y is in any other slot is 0. This leads to a thin straight line in the visualization.

The graph on the right shows the probability distribution of the hovered card being held by shuffler S (P(card N, shuffler S)). This is in essence showing a horizontal "slice" of the graph on the left (higher values in the right graph correspond to darker shaded values in the left graph).

An ideal shuffle algorithm will result in a uniform probability that any given card will appear in any slot in the cube (or equivalently, P(card N, shuffler S) = 1 / shufflerCount for 1 <= N <= cubeSize and 1 <= S <= shufflerCount). In the left visualization this looks like the same dark shading across the whole graph, and in the right visualization this looks like equal probability values across all shufflers for every card N.

Due to the variance that occurs from executing these algorithms with real cubes, you often end up with subsections of the cube that are not divided exactly evenly (and this is a guarantee for many cubeSize/shufflerCount combinations). There is a Jitter % option to simulate this variance. This leads to slightly skewed probability distributions that are clearly visible in the visualizations, however these variations should be unnoticeable in practice.

Conclusion

The CubeCon shuffle method is highly inefficient in comparison to the other analyzed algorithms. Even after 16 or so iterations of the CubeCon method the probability distributions are clearly non-uniform. In addition, it takes a minimum of S iterations (for S shufflers) for any cards from shuffler 1 to appear in shuffler S's section of the cube. Notably, this method converges faster when there are fewer shufflers. However the number of cards per shuffler increases as the shufflerCount decreases, which poses logistical problems (there is a maximum number of cards that one person can shuffle at a time).

In comparison, the "Modified CubeCon" method converges to a good shuffle in log2(S) iterations. It requires a power of 2 number of shufflers (2, 4, or 8). You can see the distributions are heavily skewed for other shuffler counts in the visualization above.

Notably, these two improved methods take the opposite approach of the "pass more, shuffle less" heuristic. In order for these methods to produce good cube shuffles each individual shuffle step must be much more "thorough". In addition, the pass/deal steps need to be fairly accurate.