[PYTHON] Ist die Lotterie rentabel? ～ LOTO7 und das Gesetz der großen Zahlen ～

Einführung

Die Frage ist: "Ist die Lotterie rentabel?"

** Nicht rentabel. ** **.

Lotterie ist ein Geschäft, bei dem die Gewinne des Veranstalters extrem hoch sind. Die Rücklaufquote des Gewinnbetrags beträgt weniger als 50% [^ 1]. Dies ist ein überwältigend niedriger Wert im Vergleich zu rund 75% bei Pferderennen, Radrennen, Bootsrennen und Autorennen. Da der Gewinn zufällig entschieden wird, ist es außerdem unmöglich, Vorhersagen wie Pferderennen zu treffen. Der Schriftsteller Rei Tachibana beschreibt dies als "eine Steuer, die auf Narren erhoben wird".

Wenn jedoch eine Gewinnchance besteht, wird es sich um den Kauf kleiner Lose mit großen zufälligen Schwankungen des Gewinnbetrags handeln. In der Wahrscheinlichkeitstheorie gibt es ein "Gesetz der großen Zahlen". Die Regel ist, dass, wenn eine Stichprobe aus einer bestimmten Wahrscheinlichkeitsverteilung extrahiert und ein Durchschnitt berechnet wird, der Durchschnitt gegen den wahren Durchschnitt der Wahrscheinlichkeitsverteilung konvergiert. Dann ** Wenn die Anzahl der Proben gering ist, kann sich die Möglichkeit einer Wiederherstellung aufgrund zufälliger Schwankungen erhöhen. ** Ich werde das überprüfen.

Umgebung

• Windows 10
• Python 3.8.3
• Jupyterlab Version 2.1.5

Experiment

Es gibt verschiedene Lottoscheine, aber diesmal habe ich mich für LOTO7 entschieden. Der Grund dafür ist, dass der erste Preis extrem teuer und hochaktuell ist und wirklich "lotterieähnlich" ist. Ich habe diesmal auch nicht über eine Verschleppung nachgedacht, weil ich ein allgemeines Beispiel betrachten wollte. Änderungen des Gewinnbetrags in Abhängigkeit von der Anzahl der Gewinneinheiten werden nicht berücksichtigt. Im Folgenden haben wir eine Klasse erstellt, um die Gewinnmenge von Loto7 zu berechnen.

import numpy as np

class Loto7:
    """
Klasse, um den Gewinnbetrag von Loto7 zu berechnen
    """
    def __init__(self, main_nums, bonus_nums):
        self.main_nums = set(main_nums) #Diese Nummer
        self.bonus_nums = set(bonus_nums) #Bonusnummer
        
    def prize_amount(self, nums=None):
        nums = self.rand() if nums is None else set(nums)
        diff_main = self.main_nums & nums
        len_main = len(diff_main) #Anzahl der Übereinstimmungen mit dieser Anzahl
        diff_bonus = self.bonus_nums & nums
        len_bonus = len(diff_bonus) #Anzahl der Spiele mit Bonusnummern

        if len_main == 7: # 1st prize
            return 600_000_000
        if len_main == 6: # 2nd and 3rd
            return 7_300_000 if len_bonus == 1 else 730_000
        if len_main == 5: # 4th
            return 9_100
        if len_main == 4: # 5th
            return 1_400
        if len_main == 3 and len_bonus > 0: # 6th
            return 1_000
        else:
            return 0
        
    def rand(self): #Wähle eine Zufallszahl
        r = np.random.choice(np.arange(1,38), 7, replace=False)
        return set(r)

Verwenden Sie die oben definierte Klasse, um zufällig eine Zahl auszuwählen und den Gewinnbetrag zu berechnen. Die Berechnungsmethode ist wie folgt.

1. Angenommen, Sie haben n Lottoscheine mit Zufallszahlen gekauft, geben Sie den Gesamtgewinnbetrag an
2. Teilen Sie es durch n, um die Menge pro Flasche zu erhalten
3. Wiederholen Sie die obigen Schritte für eine feste Zahl, um die Verteilung des Gewinnbetrags pro Flasche zu erhalten
4. Versuchen Sie für oben n mit verschiedenen Werten

Außerdem wurden die Gewinnzahlen, diese Zahl und die Bonuszahl festgelegt. Als tatsächliches Verfahren werden diese Zahlen als zufällig festgelegt angesehen. Angesichts der Beziehung zu den vom Käufer festgelegten Zahlen dachte ich, dass es in Ordnung wäre, sie zu korrigieren.

lt7 = Loto7([1,2,3,4,5,6,7], [8,9]) #Die Gewinnnummer, diese Nummer und die Bonusnummer sind festgelegt
n_lots = list(range(1,10)) + list(range(10,30,2)) + [30, 100, 300, 1000] #Anzahl der zu kaufenden Lottoscheine
reps = 1000 #Anzahl der wiederholten Einkäufe
prize_amounts = [sum([lt7.prize_amount() for i in range(n)]) / n for n in n_lots for r in range(reps)]
prize_amounts = np.array(prize_amounts).reshape(len(n_lots), reps)

Die Berechnung ist nun abgeschlossen. Wie oft gibt es dann Fälle, in denen der Kaufpreis für einen LOTO7 300 Yen oder mehr beträgt? Im Folgenden werde ich eine Grafik zeichnen, die die Beziehung zwischen der Anzahl der Käufe und der "Wiederherstellungsrate" zeigt.

recovery_rate = np.apply_along_axis(lambda x: (x >= 300).sum() / len(x), 1, prize_amounts)

plt.plot(n_lots, recovery_rate);
plt.xscale('log')
plt.xlabel('number of LOTO7 tickets')
plt.ylabel('recovery rate')
plt.show()

print(n_lots)
print(recovery_rate)

# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 100, 300, 1000]
# [0.042 0.083 0.104 0.062 0.018 0.024 0.022 0.025 0.019 0.014 0.018 0.017
#  0.022 0.012 0.009 0.024 0.024 0.024 0.024 0.028 0.002 0.008 0.011]

Daraus lassen sich zwei Dinge verstehen.

――Die am meisten "wiederherstellbare" Kaufnummer ist 3 ――In diesem Fall besteht eine 10% ige Chance, dass Sie sich erholen können.

Fazit.

** Nicht rentabel. ** **.

Wenn Sie weise sind, beenden Sie die Lotterie!

das ist alles.