Finding the seeds

Re: Finding the seeds

Sun, 04 Nov 2018 03:27:36 +0000

The l'Ecuyer PRNG is a combination of two simpler multiplicative congruential generators (MCG), which each require a seed. On the calculator, as you can see from the code, the value in [0,10^9) seeds both MCGs, but is multiplied by 40014 for one of them, which probably slightly improves randomness. There's a special case for 0 because initializing the MCGs with 0 would cause them to yield all 0s.

Re: Finding the seeds

Sat, 03 Nov 2018 23:10:30 +0000

Sweet. I just want to ask if you understand why there are two seeds used in the original algorithm. That doesn't seem to be the case on the calculator unless the calculator divides the seed into two other numbers.

Re: Finding the seeds

Sat, 03 Nov 2018 22:41:17 +0000

Not sure whether it's possible algebraically by hand, but stealing some code from the linked SO post, I wrote this c++ snippet which finds all seeds that yield a value close to 0 or 1 on the ith iteration of rand. It runs in about 3 minutes.

If you store S→rand, the actual seed is obtained by first applying int(abs(S)), then if the result is at least 10^9 or larger discarding the least significant digits. So there are only 10^9 seeds to search.

Re: Finding the seeds

Fri, 02 Nov 2018 05:24:32 +0000

Do you write code in TI Connect? If not, what do you use? I wasn't able to copy and paste your code into TIC and send it to my calculator since it said there was an invalid token. I had to copy it line by line to get it to send. From looking at your code it looks like it will take a very long time to terminate assuming N is greater than zero and less than or equal to one. I ran it in Wabbitemu at 1600% speed for 20 minutes and it didn't stop in that time. You are checking if a random number is equal to your selected number N, since real numbers are 18 bytes(144 bits) long I believe there is only a 1 in 2¹⁴⁴ or 1 in 4.5*10⁴⁴ chance of N equaling A on each iteration of the loop. Looking at the rest of your code, it looks you just counted the number of iterations of the first loop in B and reseeded the RNG. Finally, you iterated through the outputs of rand until you reach the one that made N=A.

I wouldn't really call this predicting the output of rand. From what little I know about I cryptography I believe PRNGs do this:

Input, S Random(S)→K Return Random(K) // This is pseudo code btw

And when you call it without arguments, there is actually an implicit argument, K:

Random(K)→K Return Random(K) // Assume Random() is a pure function // K is only accessible to these code blocks

By doing this the next value used to calculate Random() is never actually exposed to Eve

If Random() is not a strong RNG then you might be able to predict the next value of Random() without knowing K.

P.S. I knew the sign of the seed didn't affect the output of rand but it wasn't relevant to the code I wrote, but the fact that non-integers are rounded down was.

P.P.S Assuming I'm right about the odds I mentioned earlier then you are 10³⁵ times more likely to win the lottery with a single ticket than for N to equal A on any iteration of your first loop.

Re: Finding the seeds

Fri, 02 Nov 2018 02:14:34 +0000

A few things:

The seed values do not round to the integer. They round to the integer of the absolute value of the seed, meaning that all seeds are nonnegative integers (nonnegative instead of positive because 0 is a valid seed). This is to say that all valid seeds are natural numbers.

I don’t know if this will help, but try looking at the patterns generated in the graph I found. My personal theory is that there exists an experimentally obtainable constant that represents the frequency of the sawtooth-like graph. As we saw in my earlier post, this wasn’t really a sawtooth like wave, but finding this constant might be a good place to start, and it will give us some good intuition for solving these pretty neat problems that we have come up with. I think that looking at the graphs that our algorithms produce would be a really good way to interpret the data.

Also, here is a piece of code I came up with that might help. Given the seed and the last random number generated, it will output the next random number that you will generate. I have tested it for every TI 83 model.

:Input “SEED: “,S
:Input “NUMBER: “,N
:S→rand
:DelVar BDelVar A
:Repeat A=N
:rand→A
:B+1→B
:End
:rand→D
:S→rand
:For(C,1,B
:rand→A
:End
:Disp D
D is the next number you will generate.

Finding the seeds

Wed, 31 Oct 2018 15:35:40 +0000

When reading the page on the rand command this piqued my interest:

Note: Due to specifics of the random number generating algorithm, the smallest number possible to generate is slightly greater than 0. The largest number possible is actually 1, but since returning a result of 1 would mess up the output of randBin( and randNorm(, the actual value returned in such cases is 1-1.11e-12 (which is displayed as 1, and is "equal" to 1 for the purposes of the = command). To see 1, store 196164532 to rand and then run the random number generator.

I'm a little confused about this statement since the output of rand is not used as the next value to compute rand since seeds are rounded down to an integer. Regardless, it and CloudVariable's post inspired me to write this code.
It's purpose is to record values of rand(and their seeds) that are greater than their predecessor's value.

+ Show Code

Here is the uncommented version if you want to run the program.

Obviously I'm looking for optimizations, but let me know if you think I have a bug anywhere as well.

This program is essentially a brute force approach to finding the values I want, I'm interested in analyzing the algorithm as well, but as of now I don't understand how to do that.
I.E. is it possible to algebraically solve for seed values that output values close to 1, equal to 1, or the value closest to 0?