La loterie est-elle rentable? ～ LOTO7 et la loi des grands nombres ～

introduction

La question est: "La loterie est-elle rentable?"

** Pas rentable. ** **

La loterie est une entreprise dans laquelle les bénéfices de l'organisateur sont extrêmement importants. Le taux de retour du montant gagnant est inférieur à 50% [^ 1]. Il s'agit d'une valeur extrêmement faible comparée à environ 75% pour les courses de chevaux, les courses de vélos, les courses de bateaux et les courses automobiles. De plus, comme la victoire est décidée au hasard, il est impossible de prédire comme les courses de chevaux. L'écrivain Rei Tachibana décrit cela comme "une taxe prélevée sur les imbéciles".

Cependant, s'il y a une chance de gagner, ce sera le cas d'acheter par petits lots avec de grandes fluctuations aléatoires du montant gagnant. Il existe une «loi des grands nombres» dans la théorie des probabilités. La règle est que lorsqu'un échantillon est extrait d'une certaine distribution de probabilité et qu'une moyenne est calculée, la moyenne converge vers la vraie moyenne de la distribution de probabilité. Ensuite, ** Si le nombre d'échantillons est petit, la possibilité de récupération en raison de fluctuations aléatoires peut augmenter. ** Je vais vérifier cela.

environnement

• Windows 10
• Python 3.8.3
• Jupyterlab Version 2.1.5

Expérience

Il existe différents billets de loterie, mais cette fois j'ai choisi LOTO7. La raison en est que le premier prix est extrêmement cher et très d'actualité, et il est vraiment "de type loterie". Je n'ai pas non plus pensé au report cette fois parce que je voulais prendre un exemple général. Nous ne considérons pas les changements dans le montant des gains en fonction du nombre d'unités gagnantes. Ci-dessous, nous avons créé une classe pour calculer le montant gagnant de Loto7.

import numpy as np

class Loto7:
    """
Classe pour calculer le montant gagnant du Loto7
    """
    def __init__(self, main_nums, bonus_nums):
        self.main_nums = set(main_nums) #Ce nombre
        self.bonus_nums = set(bonus_nums) #Numéro bonus
        
    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) #Nombre de correspondances avec ce nombre
        diff_bonus = self.bonus_nums & nums
        len_bonus = len(diff_bonus) #Nombre de matchs avec numéros bonus

        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): #Choisissez un nombre aléatoire
        r = np.random.choice(np.arange(1,38), 7, replace=False)
        return set(r)

Utilisez la classe définie ci-dessus pour choisir au hasard un nombre et calculer le montant gagnant. La méthode de calcul est la suivante.

1. En supposant que vous ayez acheté n billets de loterie avec des numéros aléatoires, indiquez le montant total des gains
2. Divisez-le par n pour obtenir la quantité par bouteille
3. Répétez ce qui précède pour un nombre fixe afin d'obtenir la distribution du montant gagnant par bouteille
4. Pour ce qui précède, essayez n avec différentes valeurs

De plus, les numéros gagnants, ce numéro et le numéro bonus ont été corrigés. En tant que procédure réelle, ces nombres sont considérés comme décidés au hasard, donc compte tenu de la relation avec les nombres décidés par l'acheteur, j'ai pensé qu'il serait normal de les corriger.

lt7 = Loto7([1,2,3,4,5,6,7], [8,9]) #Le numéro gagnant, ce numéro et le numéro bonus sont fixes
n_lots = list(range(1,10)) + list(range(10,30,2)) + [30, 100, 300, 1000] #Nombre de billets de loterie à acheter
reps = 1000 #Nombre d'achats répétés
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)

Le calcul est maintenant terminé. Alors, combien de fois y a-t-il des cas où le prix d'achat d'un LOTO7 est de 300 yens ou plus? Ci-dessous, je dessinerai un graphique montrant la relation entre le nombre d'achats et le «taux de recouvrement».

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]

Il y a deux choses qui peuvent être comprises de cela.

―― Le numéro d'achat le plus «récupérable» est 3 Dans ce cas, il y a 10% de chances que vous puissiez récupérer.

Conclusion.

** Pas rentable. ** **

Si vous êtes sage, arrêtez la loterie!

c'est tout.