Benfords Gesetz

// Zahlen, die von selbst gewachsen sind - Rechnungsbeträge, Einwohnerzahlen, Aktienkurse -
// fangen nicht mit allen neun Ziffern gleich oft an. Die 1 führt in etwa 30 Prozent der
// Fälle, die 9 in weniger als 5. Der Grund: Solche Zahlen liegen gleichmäßig auf einer
// logarithmischen Skala, und dort ist der Abschnitt von 1 bis 2 viel länger als der
// von 9 bis 10. Wer Zahlen erfindet, weiß das nicht.
public static class Benford
{
    // Wie oft die Ziffer erwartungsgemäß führt. Das ist das ganze Gesetz.
    public static double Share(int digit)
    {
        ArgumentOutOfRangeException.ThrowIfLessThan(digit, 1);
        ArgumentOutOfRangeException.ThrowIfGreaterThan(digit, 9);

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

    // Die neun erwarteten Anteile in einer Reihe, bereit zum Vergleich mit einer Zählung.
    public static double[] Shares() => [.. Enumerable.Range(1, 9).Select(Share)];

    // Die führende Ziffer einer Zahl. Größe und Vorzeichen spielen keine Rolle: 0,00734 und
    // -73400 fangen beide mit einer 7 an.
    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;
    }

    // Wie oft jede Ziffer von 1 bis 9 führt. Der erste Eintrag gehört zur 1.
    // Nullen haben keine führende Ziffer und bleiben außen vor.
    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-Quadrat misst, wie weit eine Zählung von der Erwartung entfernt ist: Jede Abweichung
    // wird quadriert, damit wenige große mehr wiegen als viele kleine, und dann durch den
    // Erwartungswert geteilt, damit seltene Ziffern nicht zu streng bewertet werden.
    // Null heißt perfekte Übereinstimmung, je größer der Wert, desto verdächtiger die Daten.
    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;
    }
}

// Zwei Reihen, die niemand erfunden hat: die Zweierpotenzen und die Fibonacci-Zahlen.
// Beide wachsen durch Multiplikation, und genau um solche Zahlen geht es in dem
// Gesetz.
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-Quadrat sagt in einer Zahl, wie weit eine Zählung von der Erwartung abweicht.
// Unter 15,51 ist die Abweichung das, was der reine Zufall in 19 von 20 Fällen erzeugt.
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);

// Ein ehrliches Kassenbuch eines Großhändlers. Jede Summe ist eine Kette von Faktoren:
// so viele Kartons, so viele Stück je Karton, ein Preis je Stück und ein Aufschlag.
// Niemand wählt die Summe, sie fällt aus der Multiplikation heraus - und Produkte
// mehrerer unabhängiger Faktoren landen von selbst bei Benford.
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));
}

// Das andere Kassenbuch ist erfunden. Ein Mensch schreibt Beträge auf, die harmlos
// wirken: nichts zu Kleines, nichts zu Großes, und eher 47 oder 63 als eine
// runde 50, weil runde Beträge verdächtig wirken.
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));
}

// Die führende Ziffer soll Benford folgen, die Euro-Ziffer soll gleichmäßig verteilt
// sein: jede der zehn Ziffern etwa ein Zehntel der Fälle.
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");

// Wie oft jede Ziffer direkt vor dem Komma steht.
static int[] EuroDigits(IEnumerable<double> amounts)
{
    var counts = new int[10];

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

    return counts;
}