Why is Random class isn't really random? [clos

Question

I've read about it on a message board - Random class isn't really random. It is created with predictable fashion using a mathematical formula.

Is it really true? If so, Random isn't really random??

Answer 1

Because deterministic computers are really bad at generating "true" random numbers by themselves.

Also, a predictable/repeatable random sequence is often surprisingly useful, since it helps in testing.

Answer 2

As others have already said, Random creates pseudo-random numbers, depending on some seed value. It may be helpful to know that the .NET class Random has two constructors:

 Random(int Seed)

creates a random number generator with a given seed value, helpful if you want reproducible behaviour of your program. On the other hand,

 Random()

creates a random number generator with date-time depending seed value, which means, almost every time you start your program again, it will produce a different sequence of (pseudo-)random numbers.

Answer 3

It isn't random it's a random-like number generating algorithm and it's based on a number to generate. If you set that random number to something like the system time the numbers are more close to random, but if you use these numbers to lets say, an encryption algorithm, is the attacker knows WHEN you generate the random numbers and the algorithm you use, then it is more possible that your encryption will break.

The only way to generate true random numbers is to measure something natural, for example voltage levels or have a microphone picking up sounds somewhere or something like that.

Answer 4

The sequence is predictable for each starting seed. For different seeds, different sequences of numbers are returned. If the seed used is itself random (such as the DatetTime.Now.Ticks), then the numbers returned a adequately 'random'.

Alternatively, you can use a cryptographic random number generator such as the RNGCryptoServiceProvider class.

Answer 5

It is true, but you can always seed the random number generator with some time dependent value, or if you're really prepared to push the boat out, look at www.random.org...

In the case of the Random class though, I think it should be random enough for most requirements... I can't see a method to actually seed it, so I'm guessing it must automatically seed as built in behaviour...

Answer 6

Correct. Class Random is not absolutely totally random. The important question is, is it as statistically close to being random as you need it to be. The output from class Random is statistically as nearly random as a reasonable deterministic program can be. The algorithm uses a 48-bit seed modified by a linear congruential formula. If the Random object is created using the parameterless constructor, the 48 low-order bits of milli-second time get used as the seed. If the Random object is created using the seed parameter (a long), the 48 low-order bits of the long get used as the seed.

If Random is instanced with the same seed and make the exact same sequence of next calls are made from it, the exact same sequence of values will result from that instance. This is deliberate to allow for predictable software testing and dmonstrations. Ordinarliy, Random is not used with a constant seed for operational use since it is usually used to get unpredictable psuedo-random sequences. If two instances of Random with the parameterless constructors get created in the same clock millisecond, they will also get the same sequences from both instances. It is important to note that eventually, a Random instance will repeat its pattern. Therefore, a Random instance should not be used for enormously long sequences before creating a new instance.

There is no reason not to use the Random class except for high-security cryptographic applications or some special need where some aspect of true randomness is of paramount importance, something that is uncommon. In those cases, you really need a hardware randomizer that uses radioactive decay or infinitesimal molecular level brownian motion induced randomness to generate a random result. Sun SPARC hardware platforms had such hardware installable. Other platforms can have them too, along with the hardware drivers that give access to the randomness they generate.

The algorithm used in class Random is the result of considerable research by some of the best minds in computer science and mathematics. Given the right parameters, it provides remarkable and outstanding results. Other more recent algorithms may be better for some limited applications, but they also have performance or specific application issues that make them less suitible for general purpose use. The linear congruential algorithm still remains one of the most widely used general purpose pseudo-random number generators.

The following quote is from Donald Knuth's book, The Art of Computer Programming, Volume 2, Semi-numerical Algorithms, Section 3.2.1. The quote describes the linear congruential method and discusses its properties. If you don't know who Donald Knuth is or have never read any of his papers or books, he, amongst other things, showed that there can be no sort faster than Tony Hoare's Quicksort with partion pivot strategies created by Robert Sedgewick. Robert Sedgewick, who suggested the best simple pivot selection strategies for Quicksort, did his doctoral thesis on Quicksort under Donald Knuth's supervision. Knuth's multi-volume work, The Art Of Computer Programming, is one of the greatest expositions of the most important theoretical aspects of computing ever assembled, including sorting, searching and randomizing algorithms. There is a lot of discussion in Chapter 3 of this about what randomness really is, statistically and philosophically, and about software that emmulates true randomness to the point where it is statistically nearly indistinguishable from it for very large, but still finite, sequences. What follows is pretty heavy reading:

3.2.1. The Linear Congruential Method

By far the most popular random number generators in use today are special cases of the following scheme, introduced by D. H. Lehmer in 1949. [See Proc. 2nd Symp. on Large-Scale Digital Calculating Machinery (Cambridge, Mass.: Harvard University Press, 1951), 141-146.] We choose four magic integers:

m, the modulus; 0 < m.

a, the multiplier; 0 <= a < m.

c, the increment; 0 <= c < m.

X[0], the starting value; 0 <= X[0] < m. (equation 1)

The desired sequence of random numbers (X[n] ) is then obtained by setting

X[n+1] = (a * X[n] + c) mod m, n >= O. (equation 2)

This is called a linear congruential sequence. Taking the remainder mod m is somewhat like determining where a ball will land in a spinning roulette wheel. For example, the sequence obtained when m == 10 and X[0] == a == c == 7 is

7, 6, 9, 0, 7, 6, 9, 0, ... . (example 3)

As this example shows, the sequence is not always "random" for all choices of m, a, c, and X[0]; the principles of choosing the magic numbers appropriately will be investigated carefully in later parts of this chapter.

Example (3) illustrates the fact that the congruential sequences always get into a loop: There is ultimately a cycle of numbers that is repeated endlessly. This property is common to all sequences having the general form X[n+1] = f(X[n]), when f transforms a finite set into itself; see exercise 3.1-6. The repeating cycle is called the period; sequence (3) has a period of length 4. A useful sequence will of course have a relatively long period.

The special case c == 0 deserves explicit mention, since the number generation process is a little faster when c == 0 than it is when c != O. We shall see later that the restriction c == 0 cuts down the length of the period of the sequence, but it is still possible to make the period reasonably long. Lehmer's original generation method had c == 0, although he mentioned c != 0 as a possibility; the fact that c != 0 can lead to longer periods is due to Thomson [Compo J. 1 (1958), 83, 86] and, independently, > to Rotenberg [JACM 7 (1960), 75-77]. The terms multiplicative congruential method and mixed congruential method are used by many authors to denote linear congruential sequences with c == 0 and c != 0, respectively.

The letters m, a, c, and X[0] will be used throughout this chapter in the sense described above. Furthermore, we will find it useful to define

b = a - 1, (equation 4)

in order to simplify many of our formulas.

We can immediately reject the case a == 1, for this would mean that X[n] = (X[0] + n * c) mod m, and the sequence would certainly not behave as a random sequence. The case a == 0 is even worse. Hence for practical purposes we may assume that

a >= 2, b >= 1. (equation 5)

Now we can prove a generalization of Eq. (2),

X[n+k] = (a^k * X[n] + (a^k - 1) * c / b) mod m, k >= 0, n >= 0, (equation 6)

which expresses the (n+k)th term directly in terms of the nth term. (The special case n == 0 in this equation is worthy of note.) It follows that the subsequence consisting of every kth term of (X[n]) is another linear congruential sequence, having the multiplier a k mod m and the increment ((a^k - 1) * c / b) mod m.

An important corollary of (6) is that the general sequence defined by m, a, c, and X[0] can be expressed very simply in terms of the special case where c == 1 and X[0] == O. Let

Y[0] = 0, Y[n+1] = (a * Y[n+1]) mod m. (equation 7)

According to Eq. (6) we will have Y[k] === (a^k - 1) / b(modulo m), hence the general sequence defined in (2) satisfies

X[n] = (A * Y[n] + X[0]) mod m, where A == (X[0] * b + c) mod m. (equation 8)