SciShow is supported by Brilliant.org. Go to Brilliant.org/SciShow to get 20% off

of an annual Premium subscription. [♩INTRO] You jog onto the field for another NFL football

game or at least your team’s video game avatars

do, which, I mean, let’s face it, is about as

close as you’ll get. The virtual ref tosses his virtual coin to

see who gets dibs on the ball, and…you lose! Once again, you’re stuck letting the computer

receive first. It happens so often it seems unfair. Come to think of it, what if it is? After all, the computer’s following a fixed

program. How could it ever give you a fair, random

coin toss? The whole point of computers is that they’re

predictable! And if those coin tosses weren’t random,

how would you ever know? These questions matter for more than just

games. Getting computers to behave randomly is crucial

for simulations, scientific studies, and cybersecurity. But for all its importance, randomness is

surprisingly hard to define, and even harder to produce. Computers just aren’t that good at being

random. In fact, most computerized randomness is basically

faked; it’s totally predictable. For real, honest-to-goodness randomness, engineers turn to some pretty odd tricks. It turns out a lot of the internet is kept

secure by lava lamps, Geiger counters, and the occasional rooftop

microphone! There are lots of uses for digital randomness. Think of a pollster who wants to call a representative

sample of people, or medical researchers deciding who in their

study gets which treatment. For the statistics to work, they have to choose

the phone numbers or treatment groups randomly. Another example is predicting the behavior

of very complex systems, like weather forecasts or traffic patterns. These systems may not have simple, neat equations that tell you how they’ll

develop. Instead, simulations often model the world as a collection of small randomized components. So a traffic simulator might assume that cars

randomly show up at a highway entrance at an average rate of

10 per minute, then watch how the simulation proceeds. Randomness is also a critical part of basic

network technology. If your laptop sends a packet of data over

the wifi network at the same moment as your roommate’s, the packets collide they garble each other, and each computer

has to resend. But it wouldn’t help anything if each computer,

following the same deterministic program, tried to retransmit at exactly the

same time. You’d just get collisions over and over! Instead, they wait a random amount of time

after a collision. This type of symmetry breaking is impossible without some form of randomness. But the most common use for randomness is

both high-stakes and very necessary: encryption, which requires

secret data that an adversary can’t predict. For example, every time you connect to a secure

website like an online banking portal, your computer

and the server running the site have to agree on encryption

keys. The keys are like a more sophisticated version

of a secret decoder ring: each computer can scramble its messages so

that only someone with the same key can decode it. Obviously, no one should be able to guess

the secret key, or they’ll be able to see your bank account information or even

steal your money. So your computer and the server base the keys

on random numbers to make them nearly impossible for your online nemesis

to guess. Randomness is so valuable that when the RAND

Corporation published a 600-page book with a million random digits

in 1955, it was considered a landmark contribution

to science. Now that computers have gotten faster, the RAND book is mostly useful as a source

of hilarious Amazon reviews. But getting computers to generate numbers

that are actually random is still much harder than you might think. The first problem to solve is how to even

define randomness, because our intuitions about what’s random

aren’t always great. Take this demonstration from paleontologist

and author Stephen Jay Gould. In which image would you guess the dots were

placed totally at random? If you guessed the one on the left, you’re

not alone. Most people see the clumps in the right image

as patterns. But in fact, it’s just the opposite! It’s the even spacing on the left that’s

the result of a pattern: the program that generated the dots was modified to forbid

them from being too close together. Here’s another brain twist: tossing a coin

twenty times is just as likely to produce ten heads and then ten tails as it

is to mix them up. Neither sequence is inherently less random. To define randomness properly, the trick is

to think not just about particular string of numbers, but about an infinite sequence

of them. If a so-called random coin flipper kept producing

clumps of heads and clumps of tails forever, then we could definitively

say it’s not random. Mathematicians have used the concept of infinite

sequences to come up with a few different definitions for randomness,

but the simplest one describes randomness as unpredictability. If you were betting on future digits in the

sequence, you couldn’t find an algorithm a mathematical procedure for a computer to

follow whose predictions would make money in the

long run. The other definitions all turn out to be equivalent

to this: if a sequence is random, you can’t describe

it using some sort of algorithm. Maybe you can start to see the problem here:

if by definition, you can’t use a program to describe a random sequence, how are you supposed to write a program to

generate one? Not only that, but if you try to build a random

number generator, how can you tell if you’ve succeeded? You can’t check a whole infinite sequence

for randomness, or check all possible betting algorithms to

see if any make money. When it comes to generating random numbers,

most of the time, computers make do with pseudo-random number

generators, or PRNGs. The numbers they generate aren’t truly random

… but they’re close. The algorithms take a seed, some value to

start with, generate a number from it, update the seed,

and repeat. For instance, mathematician John von Neumann

suggested the middle square method: you take the seed,

square it, and grab the middle few digits as the next

random number. That number also serves as the next seed. Unfortunately, the middle square method tends

to start looping through the same cycle of numbers. But computer scientists have designed many

more sophisticated algorithms that do better, some with awesome names like

“Fortuna” and “the Mersenne Twister.” To check if a pseudo-random number generator is a good approximation of randomness, you can use a combination of theoretical analysis

and empirical testing. Theoretical analysis looks not at a particular

sequence of numbers, but at the process that produced them. Even if the process wasn’t truly random,

mathematicians can sometimes prove statements like “This algorithm will generate

at least 14 gazillion digits before the sequence wraps around and starts

repeating.” For empirical testing, you just generate some

random numbers and see if the statistics look right, things like whether evens and odds are equally

common. The stats will always be a bit off, so you

can never say for sure that the sequence was randomly generated. But you can at least estimate how likely the

stats you’re seeing should be. Under most statistical tests, good pseudo-random

numbers are indistinguishable from true randomness… if you don’t know the initial seed. That’s good enough for most purposes. I mean, who cares if your virtual football

game isn’t 100% unpredictable? It’s not a big deal for things like medical

research or predicting traffic patterns, either, as long as the numbers produce the

same statistics as randomness. In fact, sometimes pseudo-randomness has real

advantages. A randomized program is easier to troubleshoot

if you can make it do all the same things again by providing the same seed. And in some uses of PRNGs, determinism is

a core design feature. For example, a remote car key fob works by

running a PRNG with a seed known only to it and your car. When you click the unlock button, the fob

radios its next random number to the car, which checks that number against the

next outputs of the PRNG. To a thief, the numbers look unpredictable. But the system only works because the key

and the car produce the same series of numbers from their shared seed. Sometimes, though, PRNGs aren’t enough. Even if the algorithm is flawless, an attacker

who somehow figures out the seed can predict all the numbers. Ironically, the website Hacker News once became a poster child for this problem. Back in 2009, a security researcher realized

that the site’s random number generator, which assigned IDs to logged-in

users, was seeded with the time when the server started up. By triggering a server restart, the attacker

was able to narrow down the possible seeds to a small set of numbers. That let him predict other users’ IDs and

impersonate them. A similar problem a decade earlier allowed another team of researchers to cheat at online

poker. A leaked seed could be especially catastrophic

for a PRNG that was used for encryption: if an attacker uncovered the seed,

they could guess the encryption keys, then go back and decrypt all the previous

messages. So when the stakes are high, people get creative looking for sources of

true randomness. The most common place to look is external

noise factors that someone could in principle influence, but which the software can’t predict. For example, the website Random.org has a

rooftop microphone that captures atmospheric noise, unpredictable radio waves coming mostly from

lightning and space. Most computers use more readily available

sources of noise, like the timing between mouse clicks or incoming

network messages. Some software will even ask you to scoot your

mouse around while it’s generating big encryption keys. For the highest-stakes uses, though, you want

intrinsic randomness, something that’s guaranteed unpredictable by the laws of physics no matter what the

attacker knows or does. The Internet giant Cloudflare, which provides

encryption for about 10% of all Internet traffic, points

a video camera at a wall of lava lamps in the lobby of its

San Francisco office. Meanwhile, in its London office, a camera watches three pendulums hanging from

pendulums. Both are examples of chaotic systems: the tiniest inaccuracy in your knowledge of

their configuration will send your future predictions wildly off-base. So those camera streams are effectively random. Intrinsic randomness can also come from smaller-scale

physics. Some hardware random number generators record

tiny fluctuations in the movements of electrons in the circuitry. And Geiger counters trained on decaying hunks

of uranium will click at a rate determined by quantum mechanics, which is

inherently probabilistic. So, by the strict definition, it’s more

likely than not that your football game isn’t truly random. It’s probably flipping a coin based on a

simple PRNG seeded with the time you started playing. Even so, losing a bunch of coin flips is probably

just a brief unlucky streak; you’d be hard-pressed to show any bias with

larger statistical tests. For high-stakes contexts like security, though,

rock-solid randomness is essential, and there’s a whole cottage

industry for supplying it. Lava lamps may not be the height of cool anymore,

but as it turns out, they are still useful for security. Or maybe programmers just really miss the

70s. If you miss 1970s bedroom decor, or even if

you don’t, you can still strengthen your programming

skills at Brilliant.org/SciShow with the Computer Science Fundamentals course. Even if you know nothing about computer science, the lessons and quizzes build on each other. So it’s impossible to finish a lesson without

improving. And if you are a confident computer programmer, the quizzes might still bend your brain a

little bit, and you can always work on problems posed by other Brilliant.org

premium members. Brilliant is offering the first 200 SciShow

viewers to go to Brilliant.org/SciShow a 20% discount off of an annual premium subscription. So check it out! You’ll definitely learn and have fun, and you’ll be helping to support SciShow

while you do! So, thanks! [♩OUTRO]