Procedurally generated data has a random seed and random values generated by the process. Here is an example of what I mean:

You have a row of windows you want to either be broken or unbroken. You set you seed and loop through the "windows" randomly assigning "broken" or "unbroken" to each according to the output of the random number generator.

This is simple and straight forward......

What if I wanted to do that in reverse? If I started with all the windows "unbroken" and I throw rocks randomly and broke a few of them. I would like to reverse the process until I get THE random seed that would result in generating the windows into that state.

I'm sure it CAN be done, but how?

This process could be very useful in games that have a huge amount of "object states". Like a planet with mineral deposits. If the player collects a certain amount of them, it would be silly for the player to be able to come back to the planet and get those deposits again. And saving the state of each mineral deposit on every planet in every solar system would be crazy!

I don't see what your last paragraph has to do with the rest of the post. If the player collects a certain amount of mineral deposits, you better write that down somewhere so the next time you generate this planet you can remove the appropriate amount of mineral resources. The information of whatever the player has done to the environment can't be magically folded into a new seed for the PRNG, in particular because the seed is probably not long enough to encode all the possible things the player might have done to the planet.

To put it another way: If my building has N windows, then I need N bits of information to store whether or not each one is broken. If I have a 32 bit random seed, I can generate 2^32 unique sequences. If I have 33 windows on my building, it's impossible to generate every possible combination (there are 2^33).

If I have a random seed of 12345 and with the process, the windows generate:

1,0,1,1,0,0,0,0

where 1=="broken" and 0=="unbroken"

Then every time I go to generate the windows with seed 12345 it will look exactly the same.

If I break a window:

1,0,1,1,0,1,0,0 then the seed 12345 won't generate this result.

There IS some seed that will generate 1,0,1,1,0,1,0,0..... I want to go from the result to the seed. It's not magic, it's logic I am not fully aware of.

It could probably be done. There are only a few problems :

1. The seed has to be long enough to contain all the possible combinations, and that could be pretty long depending on the situation, as said previously.
2. The code generating the environment needs to be known. This won't be a problem if you program it yourself for your game.
3. You would probably need to do a brute-force "attack" to get the seed that would be used to generate that environment. This won't be a problem for small things, but for large chunks of data, this will take a lot of time.

The seed, as stated before, needs to be long enough to hold the data. Technically, you could make it as space-efficient as possible. But that few bytes of data really don't matter. It would be nice to have them, but having a readable format which is fast to read and write (see point three) is more important.

This process could be very useful in games that have a huge amount of "object states". Like a planet with mineral deposits. If the player collects a certain amount of them, it would be silly for the player to be able to come back to the planet and get those deposits again. And saving the state of each mineral deposit on every planet in every solar system would be crazy!

What if there are twenty thousand mineral deposits on a single planet?

[save seed]
[save 1 bit for each deposit]

Total size: 20,000 bits = 2.5kb - less than a single 32x32 bitmap.

But what if you need more details, what if you need alot more information, for an infinite number of planets?
Sadly, there is no magic compression algorithm. Videogames have to work with their limitations.

Procedural generation works awesome for generation, but any changes have to be saved using conventional means (including normal compression methods) and re-applied to the re-generated result.

This is a SUPER SIMPLE random number generator:

int RNSeed=12345;
int randomnum(void){
	RNSeed=abs(RNSeed*8786545643)%987654321;
	return RNSeed;
}

With this initial seed, the first time it's called it results in 770159010, and the second time it results in 808599291.

This will happen EVERY time I start with 12345. The problem with reversing the calculation is the modulus of 987654321. Any seed value greater than that number will be some value that can't be found and therefore the previous seed us unknown. The solution would involve a random number generator that can be reversed-- I don't know how to make that (or if it can be made at all).

All of you are either think I don't know how random generators work or you are missing my point entirely.

You have 2 windows and a 1 bit seed. 0 is both windows broken, 1 is both windows intact. You want a seed that leads to only 1 broken window... there isn't one. Now think larger scale and you'll understand why you can't do what you want to do.