I still don't see how overflows are possible here because of the low values properties reach. The int datatype has a range from –2,147,483,648 to 2,147,483,647 and those properties reach maybe +-5000. Even without trade they are affected by alot of things like buildings, units, auto-buildings..... Did you run a game with the debugger attached to see if you get any Integer Overflow Exceptions?
Or maybe the bbai.log could help to find the changes in a city causing those fluctuations.
By just looking at the end value, you are being deceived by the deviousness of most overflow errors. This is common, this is probably because of the way the storing ability of a variable type is usually illustrated (-n to +n ), as the really important thing is the number of digits used, and not the value itself.
So, the decimals or other insignificant amounts, and the value of the exponent placing the points are also important. We start and end up with int values, but in the meantime everything has been multiplied, divided, squared, and all that as float values...
I have no proof whatsoever of what I'm going to say, but my personal hypothesis is that the formula computing the changes in the properties from turn to turn probably has a few multiplications and divisions, and the number of digits in the intermediate calculations quickly gets out of hand for an int. This is the first cause of overflow errors everywhere.
I'll try to exemplify the phenomenon, but keep in mind that I don't know the formulas used so I will just invent some possible scenarios where this kind of problems may arise :
Let's say the variation par turn is the addition of the pollution produced by buildings, plus the pollution produced by population, plus a diffused value from the surrounding tiles.
Let's say we have a medium city : 31 populations; as an example, if there is a computation of the square of half the population, with a 31 pop city you get a 240.25 number.
The important thing to notice is instead of having a number with two digits, you get a number with 5 digits. This is the important thing here; multiplications (in particular squaring) often doubles the number of digits needed. 31 could theoretically be stored in a 5 bits variable, you require upward of 16 bits (depending on the precision you use on the exponent to place the floating point) to store 240.25.
A double precision float as implemented in C is considered to be able to hold a number with a precision of 16 digits.
Additions and subtractions don't do much to the size of a number (in digits), but any multiplication will likely double it. So when we add our different sources of pollution, even if they all have such kind of relatively simple computations, we'll have a 5 or 6 digits number. If then a second layer of computation is performed on it, for example to implement an "elastic band" effect on it, which is something quite common in video games and often implies some elevation to a power (=multiplications !), this amount easily doubles again.
If there is a third layer applied, whatever the reason (difficulty /game speed adjustment, modification by other overall effects), we can easily imagine another doubling of the number of digits required to keep full precision. For example, if you square a number that looks like the square of 240.25, the results already requires 20 digits to store (5*2*2 = 20) and breaks a double precision floating point storing capabilities, and probably even that of an "extended precision" double float.
This is all imagined of course, and there are in all programming languages fail-safes implemented in all the conversions from one type to another, but if the computations employed doesn't actively curtail its own precision (like discarding decimal numbers after most squaring, multiplications, and divisions operations), it is possible to get overflow errors and "apparently random" values creeping out of seemingly simple computations.
So, the problem probably arises in the intermediate operations that are performed to compute the values used to determine properties variations from turn to turn. If there are several "layers" of computations performed without intermediate conversions to int or similar measure (= rounding down and discarding of the decimal digits), this is in fact a very frequent problem.
Usually a careful look at the formulas used and their implementations to cut down on the precision, discarding negligible bits after multiplications of all kinds (squaring/ elevation to a power and divisions included) is enough to prevent such errors, but apparently the code involved is very convoluted and the modders team hasn't been able to fix it yet.
And I guess, sorry for the wall of of text, but I am starting to suspect that you are not alone in knowing what an overflow error is in principle, but not how they come to happen...