Benford's law with random integers I tried testing random integers for compliance with Benford's law, which they are apparently supposed to do. However, when I try doing this with Python,

map(lambda x:str(x)[0], [random.randint(0, 10000) for a in range(100000)]).count('1')

I get approximately equal frequencies for all leading digits. Why is this the case? Might it have something to do with how the pseudorandom number generator, the Mersenne twister, works?
 A: The linked paper is titled unfortunately, at least as regards the current conception of the word "random." The whole point of Benford's law is precisely that it doesn't hold when integers are drawn uniformly from a range that, like yours, ends at a power of $10$: a well-designed pseudorandom number generator should give numbers with asymptotically exactly a $\frac{1}{10}$ chance of each leading digit $0,1,...,9$ in decimal notation.
Benford's law applies not to properly random sources of data, but to data produced by certain real-life random processes. One simple characterization of data that obey Benford's law is as those produced by processes that exhibit more-or-less exponential growth, such as populations. Such processes produce uniformly distributed logarithms of data points, but this uniform distribution gets splayed out into the characteristic Benford's law upon exponentiation.
A: Benford's law applies only to distributions that are scale-invariant and thus applies approximately to many real-life data sources, especially when we measure with arbitrary units: If the leading-digit distribution of a sample is essentially the same whether we measure in inches or centimeters, this is only possible if the logarithm is equidistributed (or approximately so over a range wide enough to cover several orders of magnitudes).
A: Thank you for the answers, but I think I found a more explicit source of the error by reading the paper more carefully.
Benford's law does apply to random integers, but only as the upper and lower bounds go to infinity. The limit $\lim_{N\to \infty} P_N^1(1)$ (the proportion of integers from 1 to $N$ which have a leading digit of 1, as $N$ goes to infinity) diverges, and equals 1/9 at every $10^n, n\geq 2$, which explains my result. If I set the upper bound on the random integers to 12000, for example, I get different results.
A: The simplest solution to approach the logarithmical distribution using mersenne twister is by using two dimensions of randomness. First the bandwidth for the amount of digits, say 15, secondly the bandwidth, say 10-100000. With more than 10,000 iterations the results shows an almost exact benford distribution.
Hope this helps.
Regards, 
Dennes Spek 
A: Sorry for the necro add, but I needed an answer to the title of the post and found all the answers unsatisfactory for what I wanted (generating random Benford numbers) and I figured I should post an answer if anyone has the same issue as me.
First up, (this is mostly to address the post of the question, not the title) Benford's law doesn't apply to randomly selected numbers between two values.  If you select a random number between 1 and X (where X is really large) then the odds of the number starting with 1 is the same as it starting with 8.  What Benford's law is saying, you're more likely to naturally run into the number 13 than the number 83, that it's more likely for '13' to naturally describe something than '83'.
So, anyway, if you're interested in generating Benford-applicable numbers, what you want is:


*

*Generate a random number between 0.000 and 1.000

*Calculate 10 to the power of that number

*This value is the coefficient for a value in scientific notation


(you can verify that these steps will produce numbers Benford numbers, because random values between 0.000 and 0.301 will produce values between 1.0 and 2.0 - aka, the ~30.1% Benford predicts; this calculation is basically a reverse of the process Benford uses to estimate the start-digit-odds with Log10(X).)
From here, you can decide what exponentiation rules you want, depending on the scale of numbers you want (realistically, a pure Benford number generator is very rarely going to output anything larger than 3 or 4 digits.)  If you want the most realistic simulation, you can simply make each exponential value 1/10th as likely as the one before it (this would be a pure Benford prediction method.)  Or if you want a wide range of scope with more common larger numbers, simply choose an exponent at random (the starting digit would be Benford compliant, but not the scale of integer.)
For the pure option:


*Generate a second random number between 0.000 and 1.000

*Calculate 0-(Log10(1-RandomValue))

*Round this value down to the nearest integer


... for generated values between 0.0 and 0.899999..., this value will be 0.  For values between 0.9 and 0.899999999...., this value will be 1.  Etc - basically, it's a mathematical way of figuring out how many 9's are in the number before a non-9, aka, making each exponent value 1/10th as likely as the one before it.
The final answer is FirstValue x 10^SecondValue, with the whole thing rounded to an integer.
