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.

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 ^{35}** times more likely to win the lottery with a single ticket than for

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.

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.**

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?**