That question assumes some notion of randomness,
but is a very fuzzy concept to define.
What I think is the most useful definition of randomness
is the one that Andrey Kolmogorov came up with,
which is based on Kolmogorov Complexity.
This is an idea that was developed by the Russian Andrey Kolmogorov
as well as by the Argentinian Gregory Chaitin.
The idea is a way of measuring the complexity of some sequence.
And it's defined as the length of the shortest possible description of that sequence.
For this to be well-defined,
we need to understand more precisely what a description is.
One way to do this would be to say it's a turning machine
and decide on some formal way for writing down a turning machine.
But we could use any method of describing algorithms that we want.
It could be a Python program.
Whatever we select as our description language,
Kolmogorov Complexity is well-defined,
and as long as that description language is powerful enough to describe any algorithm,
it's a reasonable way to define complexity.
And we can use that to define a notion of randomness.
Some sequence is random
if the shortest way to describe that sequence
is the length of the sequence plus some constant.
That means, as we make the sequence longer,
the description gets longer at the same rate.
This matches the notion of randomness that we used informally in the quiz.
Then if there's a short program that can produce the sequence,
that means it's not random.
It has some structure to it, and the program shows us what that structure is.
If there isn't any short program that can describe that sequence,
well, that's an indication that the sequence is random--
that there's no simpler way to understand that sequence
other than to see the whole sequence.
So this seems like a useful notion for understanding randomness.
We're going to ask a quiz
to see if it seems like a useful notion form measuring randomness.
So the question is for a given sequence S,
is there a way to compute the Kolmogorov Complexity of S?
The choices are that we can.
That is the length of S plus some constant.
So the second choice is, yes, we can.
It's impractical to do this, but here's an algorithm for doing it.
We can start by initializing n to 1.
We can have a loop that keeps going
until we find the correct value of n,
which is the Kolmogorov Complexity of the string S.
And we're going to do that by looping through all the programs of length n.
This is a big step, but it's finite,
so, in theory, that would eventually finish.
And for each program, we're going to execute that program
and see if it produces S as its output.
If it does, that's the result that we want.
And the third choice is no,
it's theoretically impossible.
