Bonjour, c'est tranquillement il tranquillement. (On m'a dit sur Twitter qu'il était difficile d'appeler tranquillement.) Depuis que j'ai étudié la théorie des jeux coopératifs, j'ai implémenté le calcul de la valeur de jeu de cisaillement en Python après révision. Je viens de mettre en œuvre ce que je peux faire à la main par programmation, et je ne calculerais pas réellement la valeur de jeu de cisaillement qui serait difficile à trouver à la main. Il semble que R a un package pour calculer la valeur de lecture de cisaillement, vous devriez donc utiliser R (je me demande si le nom du package correspondait à R). C'est donc complètement un passe-temps à mettre en œuvre.
Commençons le codage après une petite explication de la valeur de jeu de cisaillement.
· Les références [Introduction à la théorie des jeux Shigeo Muto](https://www.amazon.co.jp/%E3%82%B2%E3%83%BC%E3%83%A0%E7%90%86%E8%AB%96 % E5% 85% A5% E9% 96% 80-% E6% 97% A5% E7% B5% 8C% E6% 96% 87% E5% BA% AB% E2% 80% 95% E7% B5% 8C% E6% B8% 88% E5% AD% A6% E5% 85% A5% E9% 96% 80% E3% 82% B7% E3% 83% AA% E3% 83% BC% E3% 82% BA-% E6 % AD% A6% E8% 97% A4-% E6% BB% 8B% E5% A4% AB / dp / 4532108292 / ref = sr_1_5? __Mk_ja_JP =% E3% 82% AB% E3% 82% BF% E3% 82 % AB% E3% 83% 8A & crid = 3JR92N3EW4M6 & dchild = 1 & mots-clés =% E3% 82% B2% E3% 83% BC% E3% 83% A0% E7% 90% 86% E8% AB% 96% E5% 85% A5% E9% 96% 80 & qid = 1585324546 & sprefix = ge-murironnnyuumon% 2Caps% 2C373 & sr = 8-5) [Théorie du jeu d'exercice Yukihiko Funaki](https://www.amazon.co.jp/%E6%BC%94%E7%BF%92%E3%82%B2%E3%83%BC%E3%83% A0% E7% 90% 86% E8% AB% 96-% E6% BC% 94% E7% BF% 92% E6% 96% B0% E7% B5% 8C% E6% B8% 88% E5% AD% A6 % E3% 83% A9% E3% 82% A4% E3% 83% 96% E3% 83% A9% E3% 83% AA-% E8% 88% B9% E6% 9C% A8-% E7% 94% B1 % E5% 96% 9C% E5% BD% A6 / dp / 4883840727 / ref = sr_1_1? __ mk_ja_JP =% E3% 82% AB% E3% 82% BF% E3% 82% AB% E3% 83% 8A & dchild = 1 & keywords = % E6% BC% 94% E7% BF% 92% E3% 82% B2% E3% 83% BC% E3% 83% A0% E7% 90% 86% E8% AB% 96 & qid = 1585323768 & sr = 8-1)
Notes habituelles
La distribution des gains à chaque acteur est déterminée en fonction du degré de contribution, en tenant compte de la contribution de chaque acteur à la formation d'un partenariat. Dans la théorie des jeux coopératifs, la question est de savoir comment répartir le gain après le rapprochement, et j'interprète que l'une des façons de le distribuer est la valeur de jeu de cisaillement. Il existe également des ensembles de négociation, des jin, des noyaux, etc. en tant que concepts de solution, mais je pense qu'il est plus facile d'appliquer la valeur de jeu de cisaillement, qui détermine de manière unique la distribution si les conditions sont remplies. (Il n'y a pas assez d'études ici.)
La valeur de jeu de cisaillement est dérivée de quatre axiomes.
・ Rationalité globale
・ Caractéristiques liées aux joueurs nuls
・ Caractéristiques liées aux joueurs symétriques
・ La nature de la somme du jeu
Il répond aux propriétés ci-dessus. Sherpley a prouvé qu'il n'y a qu'une seule solution qui satisfait ces quatre propriétés. Maintenant, définissons la formule de la valeur de jeu de cisaillement.
$ v $: Fonction caractéristique, $ S $: Supposons que vous ayez un partenariat.
Valeur de shearplay du joueur $ i \ en N $ dans le jeu $ (N, v)
Il existe différentes manières de saisir le nombre de joueurs et les valeurs affiliées, mais cela a été facile pour moi à mettre en œuvre. Voir également commenter dans le code pour plus de détails.
Tout d'abord, entrez le nombre de joueurs et créez un ensemble d'alliances.
import itertools
import math
n = int(input()) #Entrez le nombre de joueurs
seq = [str(i+1) for i in range(n)] #Préparation pour faire un ensemble d'alliances
All_set = []
for i in range(n): #Un ensemble d'alliances(liste)Générer un
comb = list(itertools.combinations(seq,i+1))
#itertools.Générer une combinaison unique avec combinaison
All_set.extend(comb)
new_All_set = ['0'] #Mettre dans un partenariat de 0 personnes pour un calcul ultérieur
for i in range(len(All_set)):
#Dans la liste générée ci-dessus, chaque lien est un taple, alors modifiez-le en str
s=""
a = All_set[i]
for j in a:
s += j
new_All_set.append(s)
zero_set = list(0 for _ in range(len(new_All_set))) #Un ensemble de toutes les 0 valeurs d'alliance(liste)
S = new_All_set #Une collection de toutes les alliances(liste)
V = zero_set #Ensemble de toutes les valeurs affiliées(liste)Après cela, entrez la valeur de rapprochement. Encore 0 ici
Si la valeur de match nul entre les joueurs 1 et 2 est de 2, inscrivez «12 2». Je ne pense pas que ce soit bien d'avoir une liste séparée des ensembles d'alliances et des ensembles de valeurs d'alliance, mais personnellement, c'était plus facile à gérer.
for i in range(len(new_All_set)):
inp = (input().split()) #Traitez ici la saisie de la valeur de rapprochement
if inp[0] in S: #Traitement des entrées si l'alliance saisie fait partie de l'ensemble des alliances
position = S.index(inp[0])
V[position] = int(inp[1])
if inp[0] == "ZERO":
#Lorsque toutes les valeurs de blocage restantes à saisir deviennent 0, entrez ZERO pour quitter l'instruction for.
break
sv = []
for i in range(n):
res = 0
i_in = [s for s in S if str(i+1) in s] #Un ensemble d'alliances auquel j'appartiens(liste)
i_not_in = [s for s in S if str(i+1) not in s] #Un ensemble d'alliances auquel je n'appartiens pas(liste)
for j in range(len(i_in)):
res += math.factorial(len(i_in[j])-1) * math.factorial(n-len(i_in[j])) / math.factorial(n) \
* (V[S.index(i_in[j])] - V[S.index(i_not_in[j])])
#Calculez la valeur du jeu de cisaillement ici
sv.append(["player"+str(i+1) ,res]) #Lister les valeurs de jeu de cisaillement de chaque joueur
print(sv)
c'est tout. Avant de l'implémenter, je pensais que ce serait du code plus long, mais quand je l'ai implémenté, il était étonnamment court.
Je vais mettre tout le code ensemble. (Je pense que ce serait bien de le mettre sur Github) Vous devriez pouvoir le copier et l'utiliser. Si vous obtenez une erreur, veuillez nous en informer dans les commentaires.
import itertools
import math
n = int(input())
seq = [str(i+1) for i in range(n)]
All_set = []
for i in range(n):
comb = list(itertools.combinations(seq,i+1))
All_set.extend(comb)
new_All_set = ['0']
for i in range(len(All_set)):
s=""
a = All_set[i]
for j in a:
s += j
new_All_set.append(s)
zero_set = list(0 for _ in range(len(new_All_set)))
S = new_All_set
V = zero_set
for i in range(len(new_All_set)):
inp = (input().split())
if inp[0] in S:
position = S.index(inp[0])
V[position] = int(inp[1])
if inp[0] == "ZERO":
break
sv = []
for i in range(n):
res = 0
i_in = [s for s in S if str(i+1) in s]
i_not_in = [s for s in S if str(i+1) not in s]
for j in range(len(i_in)):
res += math.factorial(len(i_in[j])-1) * math.factorial(n-len(i_in[j])) / math.factorial(n) \
* (V[S.index(i_in[j])] - V[S.index(i_not_in[j])])
sv.append(["player"+str(i+1) ,res])
print(sv)
Bien que ce soit une norme, trouvons la valeur de jeu de cisaillement dans une partie majoritaire à trois joueurs. (Reportez-vous à la P.173 de la théorie des jeux d'exercice)
Le nombre de joueurs est de trois. Les valeurs d'arrimage pour chaque immobilisation sont les suivantes.
v(123) = v(12) = v(13) = v(23) = 1 \\
v(1) = v(2) = v(3) = 0
Pour résumer l'entrée à ce moment
3
123 1
12 1
13 1
23 1
ZERO
On dirait. Le résultat du calcul est le suivant.
[['player1', 0.3333333333333333], ['player2', 0.3333333333333333], ['player3', 0.3333333333333333]]
La valeur de lecture de cisaillement de chaque joueur est correctement définie sur $ \ frac {1} {3} $. C'est tout pour cet article. Si vous rencontrez des erreurs ou des problèmes, veuillez les signaler dans les commentaires.
Recommended Posts