What's the difference between pseudo random and truly random numbers?

Question

What is the difference between a truly random number and a pseudo random number in C++? (I guess, that it wants me to make my question longer, although I've put my problem as basically as I can. I thought that was the reason my last question wasn't received so well, I could be wrong. -_-. I did google this, and I've not been successful.)

Answer 1

Pseudo random numbers aren't truly random numbers because they are generated using a deterministic process. For example, if I wanted a random number between 0 and 4 and I had access to the current time in seconds, I could generate pseudo random numbers by applying modulus 5 to the time value and this would return a different number between 0 and 4.The reason the number isn't truly random is because it is possible to predict that number before generation by knowing the time. A truly random number could never be predicted.

You could Google "determinism" for more.

Answer 2

This question could lead into a very deep philosophical rabbit hole. It is an open question if there really is a process in nature that can be truly non-deterministic. Quantum mechanics suggests that the universe is non-deterministic, but with deterministic probabilistic laws on some level. Nevertheless, this does not rule out the possibility that at some more fundamental level, a deterministic process resides, which simply appears random, at a larger scale. Randomness and chaos are intimately related, but they do not necessarily mean the same thing.

As a result, the word random could mean several different things. For practical purposes, we can consider randomness as a certain type of mathematical pattern, with certain characteristics. A random process typically follows some probabilistic distribution (i.e. white noise, pink noise, Gaussian, Poisson, ...), but it is not possible to practically predict individual results of when you sample the output of the random process.

A pseudo random number generator or PRNG uses an algorithm that employs deterministic chaos to create a pattern that appears statistically similar to a true random process. PRNGs typically use a starting point or seed. It is common to use the output of a time function to seed a PRNG. There are a multitude of different algorithms for PRGNs, which differ in performance and quality.

One significant weaknesses of a PRNG, is that the output eventually repeats or is periodic. It is also possible, if one knows the algorithm, and the starting point (seed), to recreate the exact same sequence, because digital computers are necessarily deterministic devices. Security mechanisms which rely on PRNGs often have hidden vulnerabilities, due to the PRNGs that they employ.

Certain applications, especially in security, or for example a lottery, require what is, for practical purposes considered a true random number generator. Hardware devices are available, which exploit physical phenomena. Thermal noise (i.e. random motion of electrons), for example, is governed by Quantum Mechanical behaviour and is often used in RNG hardware implementations. Certain quantum mechanical phenomena are generally considered to be random. According to most standard interpretations of Quantum Mechanics, even if you had a complete model of the system (i.e. time evolution of Schrödinger Equation) and knowledge of all the initial variables, to infinite precision, you still would not be able to predict exactly the next outcome of a measurement.

In theory, you could also use radio background noise (think television static or radio noise between the stations). Any of these signal sources can be filtered or used as input themselves for a PRNG to create high quality random sequences, without any noticeable statistical predictability.

Here is very simple toy PRNG algorithm for you to play around with and help understand the concept.

// linear congruential generator
int seed 123456789;

int rand() {
    seed = ( a * seed + c ) % m;
    return seed;
}

The above is taken from Special simple random number generator. I hope that sheds some light on your question.

Answer 3

What is the difference between a truly random number and a pseudo random number in C++?

In C++, it is possible to repeat a pseudo random number sequence. A 'truly random' number (I think not supported by C++ nor C, without custom hardware) can not be repeated.

---

Marked as C++, so here is one C++ approach.

Lately I have been using what C++ provides, but I still control the range of my numbers by shuffling a simple vector of values. This also supports applying the same random shuffle to more than one test, or to repeat a sequence.

typedef std::vector<int> IntVec_t;  // a convenient type

IntVec_t  iVec;                     // a std vector of int

for (int i=1; i<=32; ++i)
   iVec.push_back(i);               // add 32 ints, range 1..32

{        
   std::random_device rd;      // the generator uses this
   std::mt19937_64 gen(rd());  // there are several generators available

   std::shuffle (iVec.begin(), iVec.end(), gen); // shuffle the vector
}

initialized to: ( 16 elements to a line)

 1    2    3    4    5    6    7    8    9   10   11   12   13   14   15   16 

17   18   19   20   21   22   23   24   25   26   27   28   29   30   31   32 

Shuffled contents (possible) :

29   26   12   16   20    7   31   28   30   18    4   23   17   14   32    1 

11   13    5    6    9    2   19   10   21   24    3    8   25   27   22   15 

Answer 4

In short pseudo numbers have repition while

truly random numbers have no repition its have a seed such as a time or anything else which will obviously different each and every time.