Since we're on the subject of retraining intuitions, I was reminded of a little shell script I created a few years ago in order to train my intuitive understanding of randomness.

Humans are notoriously bad at understanding randomness. As a fun experiment, try grabbing a pen and paper and simulating (in your head) twenty coin tosses. Write down the sequence of H's and T's. Now grab a coin and actually do twenty coin tosses, and write out that sequence of H's and T's. Go on, I'll give you a few minutes.

Look at the two different sequences. What is the longest "run" (sequence of one letter, H or T, in a row) in the artificially generated sequence? What is the longest in the coin-generated sequence? Most people generate a "random" sequence of coins that have no more than three H's or T's in a row, whereas actual sequences of twenty coin tosses contain tend to contain at least one run of length four.

We aren't very good at generating randomness.
Humans are predictable when playing Rock-Paper-Scissors. When asked to pick a number randomly between one and twenty, seventeen is the most commonly chosen number.

As you might expect, we also aren't very good at identifying randomness. Humans are prone to seeing patterns in random data, as evidenced by how people see "hot hands" in basketball even when a player is shooting no better than chance, or how people complained that the iPod Shuffle's random algorithm wasn't random enough, because it played the same songs again too soon.

This tendency to see patterns in randomness is occasionally harmful. In tests where a green light is lit up 80% of the time (according to some random process) and a red light is lit up the other 20% of the time, where the subject must guess which light will be lit up, rats and pigeons always pick green while humans try to predict the pattern. In these scenarios, the rats (who always guess green) are right 80% of the time, while the humans (who tend to guess green 80% of the time but not the right 80% of the time) are correct only about 68% of the time.

(I can't find any actual studies showing this, only dozens of articles which reference the experiment without citing their sources. If anyone knows the actual source or can debunk the claim, please let me know.)

(EDIT: Reference found, thanks to Scott Worley.)

Humans are very very good at detecting patterns. Indeed, pattern matching seems to play a big role in human intelligence. But sometimes our pattern-matchers misfire and see patterns where there are none. This can lead to incorrect beliefs and poor predictions, as outlined above.

In fact, I expect that some of these pattern-matching misfires directly impact our daily lives. Friendships and social connections, along with many other opportunities, are often formed on the basis of early interactions. If you have a tendency to see patterns where there are none, then you might falsely detect a negative pattern (in the same way people see hot hands in basketball where there is none) and miss out on worthwhile opportunities.

A better intuition for what the background noise looks like helps you separate the false patterns from the real ones.


(This section will only be meaningful to programmers interested in a small Haskell script that helps train randomness intuition.)

With this in mind, I wrote a little program that helps train my intuition for what random patterns look like. It hasn't drastically changed my life, but it seems to have given me an improved ability to forestall the firing of my pattern-matcher, to hold back a bit before passing judgement. This is one of those small compounding improvements that helps me to remain calm when others would start getting stressed and which helps me see opportunities that others have discarded.

It occurred to me that others may find my little "Randometer" games to be useful, so I've made the code public. It's not the most user-friendly script (it's text-based), but hopefully it will be useful to some. (And besides, someone else might be able to take either the code or the idea and make it better. There's definitely a lot of room for improvement.)

It's a Haskell script. You can build and install it using cabal, and run it in a terminal emulator. (You may also just install it from hackage.) Unfortunately, it's poorly documented and the code is still a bit rough.


Whether you use my tools or some other method, it might well be worth a few hours of your life to retrain your intuition for randomness. It may help you avoid premature judgements.