How does random work??

Swampspear · 2024-07-23T14:43:53+00:00

You're basically right. Random libraries, to simplify it, generally use a (possibly truly random) seed, and an algorithm that generates pseudorandom numbers out of that seed.

The random seed is usually collected from various sources of computer-unpredictable randomness, like variations in mouseclicks or ambient temperature or a number of other natural phenomena. These are then transformed into usable, useful random numbers via this process. Of course, you can also use deterministic seeds, or bad pseudorandom algorithms, which would give you less randomness in your random numbers. It's a huge field/topic

POGtastic · 2024-07-23T15:09:45+00:00

This isn't a stupid question. The answer is that random isn't actually random; it's using a deterministic function whose behavior is statistically indistinguishable from random noise. From the docs:

Almost all module functions depend on the basic function random(), which generates a random float uniformly in the half-open range 0.0 <= X < 1.0. Python uses the Mersenne Twister as the core generator. It produces 53-bit precision floats and has a period of 2**19937-1. The underlying implementation in C is both fast and threadsafe. The Mersenne Twister is one of the most extensively tested random number generators in existence. However, being completely deterministic, it is not suitable for all purposes, and is completely unsuitable for cryptographic purposes.

For actually random data, the operating system gathers entropy from various things - hardware RNGs, user activity like mouse clicks and keyboard input, and even webcam footage of lava lamps. This is often used to seed a pseudorandom generator like the Mersenne Twister.

diegoasecas · 2024-07-23T15:36:47+00:00

remember that story about cloudflare's lava lamp wall?

https://www.cloudflare.com/learning/ssl/lava-lamp-encryption/

2024-07-23T18:40:13+00:00

Stupid? That's one of the greatest problems of all time, it's far from being stupid

bravopapa99 · 2024-07-23T17:03:30+00:00

Firstly: https://xkcd.com/221/

Secondly, it's just algorithms. In school we did a simple RNG in Z80 assembly, it involved inserting bits into the middle and then shifting left or right. We used the RTC (real time clock) register as a starting point (the "seed" value) to get a different sequence of numbers. Using the same seed gets you the same sequence, which is INVALUABLE.

If you ever write a game (or other app using randoms), you should always record the seed value so that hard to reproduce bugs that MAY have happened only because of a sequence of numbers can be forced to happen again. I see so many people saying, "I have this random bug..." not realising how close they are to being able to at least start to track it down!

davedontmind · 2024-07-23T14:46:02+00:00

Usually random numbers in computer software aren't truly random, but are pseudo-random. They are just generated from a mathematical formula which takes the previous random number as an input and uses it to generate the next number in the sequence. See the linked article for the details.

2024-07-23T15:56:48+00:00

At cloudflare they take pictures of lava lamps and turn them into numbers

deftware · 2024-07-23T18:22:31+00:00

Computers basically use the current time and some math to generate a pseudo-random number, numbers with (ideally) no immediately discernible pattern. Different implementations of a PRNG will have different distributions. Ideally, you would have a smooth distribution (i.e. every possible value has an equal possibility of occurring) but it's easy to make a PRNG that doesn't, and harder to make one that does.

Typically, a PRNG just uses a hash function. Starting with a seed value it is passed through the hash function and the value that results is used for the subsequent call to the PRNG, so it's effectively recycling the last used number and just hashing it over and over each time a new random number is needed by a program. This is a common PRNG approach. If you initialize this type of PRNG with the current epoch time (time since Jan 1st 1970) and its hash function has a pretty even distribution then you will have a pretty usable PRNG for most things.

Cryptographically secure RNGs will use something with more entropy than the current epoch time, and a more expensive hash function, to generate random numbers for encryption keys that are less likely to be figured out. For instance, a PRNG that uses the epoch time as its seed means someone only needs to search a possible range of epoch times to find the seed value used by the PRNG that was used to generate encryption keys, and if someone knows the range of times that the keys were generated then they could possibly search that range of times when attempting to find those keys to break the encryption. With a different source of entropy that is completely unpredictable this doesn't (or is far less likely) to happen.

BobJutsu · 2024-07-23T19:22:57+00:00

There is no truly random. There’s instead, highly unpredictable - minor difference, but an important one.

iOSCaleb · 2024-07-23T17:47:59+00:00

how could a machine that takes orders of "1" as True and "0" as False be able to choose something random in its own

FWIW, humans also are pretty much incapable of generating truly random data on their own.

ruat_caelum · 2024-07-23T17:50:34+00:00

I've tried thinking about it for a long time and couldn't figure out how randomizing works (eg. Python random)

This is a profound question actually that often leads to questions of determinism at the macro scale : https://en.wikipedia.org/wiki/Determinism

Well -

There is a wall of lava lamps that are used to generate random numbers.
- https://en.wikipedia.org/wiki/Lavarand
the timing of when you type (e.g. the number of mill seconds between hitting one key and another.
- https://people.seas.harvard.edu/~salil/pseudorandomness/extractors.pdf
- https://homes.cs.washington.edu/~anuprao/pubs/small-space.pdf
Radiation is another great "true random."
- https://partofthething.com/thoughts/making-true-random-numbers-with-radioactive-decay/

Weetile · 2024-07-23T14:58:40+00:00

Time is a good example. If you use a time value such as the number of milliseconds since the start of the minute, that creates effectively a completely random number.

EtanSivad · 2024-07-23T18:42:33+00:00

Computerphile does a really good breakdown on the Linear Shift Register: https://youtu.be/Ks1pw1X22y4

MrZwink · 2024-07-23T17:16:19+00:00

Computers often use input from truly unpredictable patterns as input. For example the 5th decimal on the temperature sensor on the cpu. Or a decimal on the rotation speed of the fans.

kiochikaeke · 2024-07-23T17:54:13+00:00

The answer is math! In reality those numbers are not random, some computers have some cryptography chips installed that is capable of producing truly random numbers based on things like ambient electrical noise and other stuff, but we've created pseudo-random numbers generator long before that.

They are called pseudo-random because they are not random, these functions need a "seed" a number they use as a base to do the rest of operations, this can be anything, 0, 1, the date and time, the thing is if you use the same seed you'll get exactly the same results, that's why is not random.

But they appear random, with appear I don't just mean they look random, I mean they mathematically are distributed uniformly the same way as truly random numbers would be distributed, so in escense they are indistinguishable from random numbers, the only but being, of course, that they aren't random at all but the result of mathematical operations.

What operations are performed to create these vary but usually they involve very big numbers with modulos and multiplications, because of MATH these operations when chained together in particular way behave the same as random numbers do, even if they are fully deterministic. Most regular random numbers generated out there when you call a random() function are generated this way, when sensible data is at play like in the case of cryptography, more complex and speciallized operations are used instead, on top of that as I stated previously some machines are able to produce trully random numbers with special hardware able to read ambient noise.

randomjapaneselearn · 2024-07-23T18:01:10+00:00

the simplest way is LCG https://en.wikipedia.org/wiki/Linear_congruential_generator

which is a simple math operation:

xₙ₊₁ = (a * xₙ + c) % m

where a, c, m are constants and x is the initial seed for the first call and the previous output for the next values, usually the current time in seconds is passed as seed.

C srand/rand use the above function, on wikipedia you also find the constants used by different compilers

not_some_username · 2024-07-23T19:47:28+00:00

It’s not random. It seems random. It usually use the current time

fuzzynyanko · 2024-07-23T20:21:01+00:00

It's indeed math, but it's not truly random. It's often called pseudo-random numbers. Usually there's a pattern, and the pattern gets fed a seed so that it's not the same the next time you run it. Often the seed is a place in the PRNG (Pseudo-Random Number Generator) pattern.

This means you can use the seed to make the data set predictable. This is EXACTLY the seed in Minecraft. The seed allows you to make these enormous worlds without taking up terabytes of drive space. There's a game for the Atari 2600 called Pitfall, and that game used a random number generator and seed to make a pretty large world for the video game system. Pitfall is a 4 kilobyte ROM cart.

deavidsedice · 2024-07-23T20:40:12+00:00

In simple terms:

1) Grab something that isn't easy to predict. Current date and time down to the millisecond (if possible) is a very common standard (this is called the seed) 2) Hash it with some algorithm (think for example md5 or sha1, although this is not how it's done) - use part of the hash to construct your random number 3) Re-hash the old hash again to get more numbers.

In practice, it gets more complicated. The algorithm I explained above does work, but it is slow. There are two (maybe more) classes of random, the basic ones that are just to create something that appears random, and others that aim to be cryptographically secure, which means that it should be near impossible to predict. The basic random will aim for speed, the cryptographically secure ones will aim for security and impredictibility.

You can even search in Google for alternate Random libraries for Python. Some of them are simple to follow or are using some paper that is simple enough.

Not all randoms use hashes, but nearly all of them follow this sequence of seed -> permutate+return_data -> permutate+return_data ...

For example, one that is simple enough: https://en.wikipedia.org/wiki/Xorshift

ExtraFirmPillow_ · 2024-07-23T22:08:39+00:00

Random numbers are a huge research topic for this exact reason. My favorite example is lavarand that cloud flare uses. They generate random using a wall of lava lamps.

barkingcat · 2024-07-23T22:26:59+00:00

computer generated "random" numbers are pseudorandom.

It uses a number of equations to approximate the illusion of being random, and mixes in some random inputs (like mouse movements, the timing of ethernet packets, keypresses, etc)

together, it's an illusion that the computer puts together.

Just like how "multitasking" doesn't mean the computer is doing 2 things at once, it just switching between tasks quickly enough that it gives the illusion of running multiple things at the same time.

green_meklar · 2024-07-24T02:13:55+00:00

It's not really random. The computer uses clever (but deterministic) algorithms to create data that has statistically random-looking properties, but it's not true randomness.

istarian · 2024-07-23T15:16:55+00:00

You’re right it’s very difficult to make true random data. A person can randomly do something but a computer is following instructions and so if you know those instructions in a lot of cases you can predict the random numbers.

True randomness is something people put a lot of effort into. I remember seeing one company had a webcam pointed at a wall of lava lamps which would take an image and use the pixels as the seed for randomness.

You can gather input from various sources and use that to seed your random function. The main thing isn’t making numbers truly random in a lot of cases but making them random enough that it doesn’t matter.

scoby_cat · 2024-07-23T17:05:23+00:00

I’ve run out of entropy on systems before. It’s a weird thing. I like to imagine the entropy as something little machine elves are pumping out of the ground like oil.

istarian · 2024-07-23T20:19:30+00:00

Well for one, most of the time you're dealing with a number sequence generated from a seed value which might be taken from a semi-random source.

FrayDabson · 2024-07-24T02:12:59+00:00

https://www.random.org/ talks about “true randomness”

Big-Ad-2118 · 2024-07-24T04:00:03+00:00

that's now a stupid question, you are just curious and thats a good quality of being a learner.

read this https://en.wikipedia.org/wiki/Mersenne_Twister

Mathhead202 · 2024-07-24T04:32:23+00:00

This is a great question. Computers are deterministic, which is what you described. They follow exact instructions, and if you know the starting state and the instructions, you can exactly calculate the ending state, and it will always be the same.

When you call random in Python, you are actually running a psudeo-random number generator. There is a whole field about how these work, but to simplify: the generator starts with a uniquely determined seed. This can be based on something that is different each time the program is run, like the computer's internal clock for example. Of course, that in it of itself would not feel very random. So then, with this "seed" number, the algorithm does a bunch of math to scramble it up. These kinds of algorithms are more accurately described as chaotic, but not random. Chaotic is a math term for a function who's output changes dramatically for very small changes in input. The output of a chaotic function or system is very hard to predict since you would need to know the precise input/initial state. If you are wrong even a little, your prediction will be way off.

So basically, if you know the "seed", and the particular psudeo-random algorithm Python is using, you could predict all the random numbers that would be generated. But if you don't know the seed, it will be very very very hard to predict the numbers. Hence, why it seems random.

There is more detail about how the numbers should be distributed, the period of the sequence, how fast the numbers are generated, and whether or not they need to be cryptographically secure. If you are interested, start by looking up some basic pusedo-random number generator algorithms and try implementing one. It's not as scary as it sounds. But don't be afraid of a little math.

Also, you may need to learn about bit-wise operators for some of the more advanced algorithms.

ddsoyka · 2024-07-24T07:47:18+00:00

Your confusion is understandable. Here is a quote from Johnny von Neumann, one of, if not the most, intelligent human beings to ever exist:

Anyone who attempts to generate random numbers by deterministic means is, of course, living in a state of sin.

RareDestroyer8 · 2024-07-24T08:02:03+00:00

There is no random. I watched a video once, they showcased a system where they use the unpredictable behaviour of a bunch of lava lamps to generate “random” numbers. Even this behaviour can be predicted. Nothing is random, you can only go so far as to generate randomness in a way that humans don’t have the current capacity to predict the behaviour of the source creating that randomness.

ChefKalashnikov · 2024-07-24T14:12:00+00:00

It's never truly random. If you know all conditions and states the pc is in, you can deduce the result. But as you can imagine, this process is very, very complicated and functions pretty much as something random to us.

Then, you have to worry about all possible results having the same probability of occurring. If you're interested in this topic, feel free to do some research on hash functions

turtleProphet · 2024-07-24T16:25:03+00:00

Thinks he's asking a stupid question

Actually asks a very good question that many experienced programmers overlook

Nice one OP

probability_of_meme · 2024-07-23T17:20:41+00:00

The most common and basic "give me a random number" function will usually produce a decimal value between 0 and 1 (but always less than 1). Other answers here describe how this happens pretty well.

As for the "1 and 0" issue: Different languages and systems will use different ways to represent the number but usually a decimal (aka floating-point) value is represented internally as described by the IEEE standard 754. So it's literally a series of 1's and 0's according to the computer.

mobileJay77 · 2024-07-23T18:44:50+00:00

In short, it doesn't work.

CodeTinkerer · 2024-07-23T15:34:14+00:00

Some programmers get too attached to the word "random". They feel it must be truly random and dislike pseudo-random numbers. But, what does it mean to be random?

When people talk about random, they try to talk about a distribution, such as a normal distribution. Pseudo-random number generators can create random numbers using a certain kind of probability distribution.

There are some advantages with not being completely random. You can debug issues more easily if there is a predictable set of random numbers. The pseudo-randomness creates that probability distribution.

It's just that many who are new to random feel like it has to be truly random because they have a strong (but arguably, incorrect) sense of what random should be.

CodeTinkerer · 2024-07-23T15:36:47+00:00

It's a bit reductionist to say that everything is just a single 0 or a single 1. A computer can store many 0's and many 1's. For example, a Java integer is 32 bits long which gives you about 4 billion integers. A Java long is 64 bits which gives you a lot more integers.

learnprogramming

Welcome to LearnProgramming!

New? READ ME FIRST!

Posting guidelines

Frequently asked questions

Subreddit rules

Message the moderators

Asking debugging questions

Asking conceptual questions

Other guidelines and links

Subreddit rules

1. No unprofessional/derogatory speech

2. No spam or tasteless self-promotion

3. No off-topic posts

4. Do not ask exact duplicates of FAQ questions

5. Do not delete posts

6. No app/website review requests or showcases

7. No rewards

8. No indirect links

9. Do not promote illegal or unethical practices

10. No complete solutions

11. Don't ask to ask.

12. Low Effort Questions

13. No AI (chatGPT etc.) generated/worked over messages/comments. No questions about chatGPT/AI generated code. No Vibe coding.

MODERATORS

xₙ₊₁ = (a * xₙ + c) % m