Benford's Law

// Numbers that grew on their own - invoice totals, populations, share prices - do not
// start with all nine digits equally often. The 1 leads in about 30 percent of the
// cases, the 9 in less than 5. The reason is that such numbers are spread evenly on a
// logarithmic scale, and on that scale the stretch from 1 to 2 is far longer than the
// one from 9 to 10. Anyone who makes numbers up does not know that.
public static class Benford
{
    // How often the digit is expected to lead. This is the whole law.
    public static double Share(int digit)
    {
        ArgumentOutOfRangeException.ThrowIfLessThan(digit, 1);
        ArgumentOutOfRangeException.ThrowIfGreaterThan(digit, 9);

        return Math.Log10(1 + 1.0 / digit);
    }

    // The nine expected shares in a row, ready to be compared with a count.
    public static double[] Shares() => [.. Enumerable.Range(1, 9).Select(Share)];

    // The leading digit of a number. Size and sign do not matter: 0.00734 and
    // -73400 both start with a 7.
    public static int LeadingDigit(double number)
    {
        var value = Math.Abs(number);

        if (value == 0 || double.IsNaN(value) || double.IsInfinity(value))
            throw new ArgumentOutOfRangeException(nameof(number), "This number has no leading digit.");

        while (value >= 10)
            value /= 10;

        while (value < 1)
            value *= 10;

        return (int)value;
    }

    // How often each digit from 1 to 9 leads. The first entry belongs to the 1.
    // Zeros carry no leading digit and are left out.
    public static int[] Count(IEnumerable<double> numbers)
    {
        var counts = new int[9];

        foreach (var number in numbers)
        {
            if (number != 0)
                counts[LeadingDigit(number) - 1]++;
        }

        return counts;
    }

    // Chi-square measures how far a count is from what was expected: every deviation
    // is squared, so that a few large ones weigh more than many small ones, and then
    // divided by the expected value, so that rare digits are not judged too harshly.
    // Zero means a perfect fit, the larger the value the more suspicious the data.
    public static double ChiSquare(int[] counts, double[] shares)
    {
        if (counts.Length != shares.Length)
            throw new ArgumentException("There has to be one expected share per count.", nameof(shares));

        var total = counts.Sum();
        var sum = 0.0;

        for (var i = 0; i < counts.Length; i++)
        {
            var expected = total * shares[i];
            var difference = counts[i] - expected;

            sum += difference * difference / expected;
        }

        return sum;
    }
}

// Two series that nobody made up: the powers of two and the Fibonacci numbers.
// Both grow by multiplication, and that is exactly the kind of number the law
// is about.
var powers = new List<double>();
var fibonacci = new List<double>();

var power = 1.0;
double previous = 1, current = 1;

for (var i = 0; i < 500; i++)
{
    powers.Add(power);
    power *= 2;

    fibonacci.Add(previous);
    (previous, current) = (current, previous + current);
}

var powerCounts = Benford.Count(powers);
var fibonacciCounts = Benford.Count(fibonacci);

Console.WriteLine("digit  expected  powers of two  fibonacci");

for (var digit = 1; digit <= 9; digit++)
{
    Console.WriteLine(
        $"{digit,5}  {Benford.Share(digit),7:0.0%}  " +
        $"{powerCounts[digit - 1] / 500.0,12:0.0%}  {fibonacciCounts[digit - 1] / 500.0,9:0.0%}");
}

// Chi-square says in one number how far a count is from the expectation.
// Below 15.51 the deviation is what chance alone would produce in 19 of 20 cases.
Console.WriteLine();
Console.WriteLine($"chi-square, powers of two: {Benford.ChiSquare(powerCounts, Benford.Shares()),6:0.00}");
Console.WriteLine($"chi-square, fibonacci:     {Benford.ChiSquare(fibonacciCounts, Benford.Shares()),6:0.00}");

const int entries = 500;

var random = new Pcg(20240921);

// An honest cash book of a wholesaler. Every total is a chain of factors:
// so many boxes, so many pieces in a box, a price per piece and a markup.
// Nobody picks the total, it falls out of the multiplication - and products
// of several independent factors land on Benford all by themselves.
int[] perBox = [6, 12, 24, 48];
var honest = new List<double>();

for (var entry = 0; entry < entries; entry++)
{
    var boxes = 1 + random.Next(12);
    var pieces = perBox[random.Next(perBox.Length)];
    var price = 0.20 + random.NextDouble() * 7.80;
    var markup = 1.0 + random.NextDouble() * 0.6;

    honest.Add(Math.Round(boxes * pieces * price * markup, 2));
}

// The other cash book was made up. A person writes down amounts that look
// harmless: nothing too small, nothing too large, and rather 47 or 63 than a
// round 50, because round numbers feel conspicuous.
int[] favourites = [3, 4, 6, 7, 8];
var invented = new List<double>();

for (var entry = 0; entry < entries; entry++)
{
    var euros = (2 + random.Next(8)) * 10 + favourites[random.Next(favourites.Length)];

    invented.Add(euros + (random.Next(2) == 0 ? 0 : 0.5));
}

// The leading digit should follow Benford, the euro digit should be spread
// evenly: each of the ten digits about a tenth of the time.
var evenly = Enumerable.Repeat(0.1, 10).ToArray();

Console.WriteLine("cash book   leading digit   euro digit");

foreach (var (name, book) in new[] { ("honest", honest), ("invented", invented) })
{
    Console.WriteLine(
        $"{name,-9}   {Benford.ChiSquare(Benford.Count(book), Benford.Shares()),13:0.0}   " +
        $"{Benford.ChiSquare(EuroDigits(book), evenly),10:0.0}");
}

Console.WriteLine();
Console.WriteLine("chance alone stays below 15.5 and 16.9 in 19 out of 20 cases");

// How often each digit stands directly in front of the decimal point.
static int[] EuroDigits(IEnumerable<double> amounts)
{
    var counts = new int[10];

    foreach (var amount in amounts)
        counts[(int)amount % 10]++;

    return counts;
}