I noticed this weird thing a long time ago, back in 2013. I used to carry a deck of cards and a notebook full of chaotic ideas.

One day I was messing with shuffles trying to find the "best" way to generate entropy.

I tried the Faro shuffle (aka the perfect shuffle). After a couple of rounds with an ordered deck, the resulting sequence looked eerily familiar.

It matched patterns I'd seen before in my experiments with symbolic billiards.

Take a deck of cards where the first half is all black (0s) and the second half is all red (1s).

After one perfect in-shuffle (interleaving the two halves), the sequence becomes:

  1, 0, 1, 0, 1, 0, ...

Do it again, and depending on the deck size, the second half might now begin with 0,1 or 1,0 - so you’ve basically rotated the repeating part before merging it back in.

What you're really doing is:

* take a repeating pattern
* rotate it
* interleave the original with the rotated version

That's the core idea behind this generalized shuffle:

`function shuffle(array, shiftAmount) {`  
  `let len = array.length;`  
  `let shuffled = new Array(len * 2);`  
  `for (let i = 0; i < len; i++) {`  
`shuffled[2 * i] = array[(i + shiftAmount) % len];`  
`shuffled[2 * i + 1] = array[i];`  
  `}`  
  `return shuffled;`  
`}`

Starting with just \[0, 1\], and repeatedly applying this shuffle, you get:

  \[0,1\] → \[1,0,0,1\] → \[0,1,1,0,1,0,0,1\] → ...

The result is a growing binary sequence with a clear recursive pattern - a kind of symbolic fractal. (In this example, with shift = length/2, you get the classic Morse-Thue sequence.)

Now the weird part: these sequences (when using a fixed shift amount) are bitwise identical to the output of a simple formula:

  Qₖ = floor(k·x) % 2

…for certain values of x

This formula comes up when you reduce the billiard path to a binary sequence by discretizing a linear function.

So from two seemingly unrelated systems:

* a recursive shuffle algorithm
* and a 2D symbolic dynamical system (discrete billiards)

…we arrive at the same binary sequence.

Demo: [https://xcont.com/perfectshuffle/perfect\_shuffle\_demo.html](https://xcont.com/perfectshuffle/perfect_shuffle_demo.html)

Full article: [https://github.com/xcontcom/billiard-fractals/blob/main/docs/article.md](https://github.com/xcontcom/billiard-fractals/blob/main/docs/article.md)



Recursive perfect shuffle with shifting produces fractal binary sequences - identical to floor(k·x)%2 from symbolic billiards