Si on leur donne une puissance de traitement infinie, existe-t-il un algorithme qui jouerait parfaitement aux échecs?


29

Existe-t-il un tel algorithme où, si on lui donne une puissance de traitement infinie, un ordinateur pourrait parfaitement jouer aux échecs pour qu'il ne perde jamais?

Si oui, où puis-je trouver un pseudo-code pour cela?


8
Qu'entendez-vous par échecs parfaits?
Herb Wolfe

5
@HerbWolfe Je suppose qu'il veut dire qu'il ne fait jamais un mouvement qui permet à son adversaire de le forcer à perdre et démissionne si, et seulement si, chaque mouvement possible permet à son adversaire de le forcer à perdre.
David Schwartz

5
@DavidSchwartz - "échecs parfaits", bien sûr, ne peut pas être défini. La «puissance de traitement infinie» non plus. Est-ce à dire "exécute toutes les séquences d'instructions en 0 temps"? "Dispose d'un nombre infini de processeurs"? FWIW - ma définition des "échecs parfaits" est "ne perd jamais une partie".
Bob Jarvis - Réintègre Monica

24
Oui, ça s'appelle la force brute. Avec une puissance de traitement infinie, vous n'avez pas besoin de procéder à l'élagage alpha-bêta, bien que vous ayez également besoin d'une quantité de stockage assez importante pour contenir votre arbre de recherche.
Michael

4
Le concept d'un "algorithme" et le concept de puissance de traitement infinie ne se mélangent pas vraiment. La théorie des algorithmes et de la calculabilité est basée sur l'hypothèse de l'obtention d'un résultat en un nombre fini d'étapes. Si vous disposez d'un nombre infini d'étapes, la distinction entre ce qui est calculable et ce qui ne l'est pas disparaît.
Michael Kay

Réponses:


62

Existe-t-il un algorithme? Oui. Selon le théorème de Zermelo , il y a trois possibilités pour une partie déterministe finie à deux informations parfaites comme les échecs: soit le premier joueur a une stratégie gagnante, soit le deuxième joueur a une stratégie gagnante, soit l'un ou l'autre joueur peut forcer un match nul. Nous ne savons pas (encore) de quoi il s'agit pour les échecs. (Les dames, en revanche, ont été résolues : chaque joueur peut forcer un match nul.)

Conceptuellement, l'algorithme est assez simple: construisez un arbre de jeu complet , analysez les nœuds terminaux (les positions de fin de jeu) et effectuez le mouvement initial gagnant, démissionnez ou offrez un match nul.

Le problème réside dans les détails: il y a environ 10 43 positions possibles, et un nombre encore plus grand de mouvements (la plupart des positions peuvent être atteintes de plusieurs manières). Vous avez vraiment besoin de votre ordinateur infiniment puissant pour en profiter, car un ordinateur qui peut tirer parti de cet algorithme ne peut pas entrer dans l'univers connu ou ne terminera le calcul que quelque temps après la fin de l'univers.


13
@Wildcard Non, il ne suppose rien: il contient juste tous les jeux d'échecs légaux possibles et il choisira tous ceux où le joueur à proximité ne perd pas.
gented

11
@gented, je faisais allusion à l'étape de «démission» de l'algorithme. Ce n'est pas du tout une étape nécessaire.
Wildcard

38
La règle des trois répétitions délimite l'espace de recherche, de sorte que l'ordinateur n'a pas besoin d'être infiniment puissant, simplement astronomiquement puissant.
Hoa Long Tam

9
Pour référence, comparer une borne inférieure pour le nombre de jeux possibles ( 10 ^ 120 ) au nombre d'atomes dans l'univers observable (de l'ordre de 10 ^ 80 ). L'algorithme le plus simple devrait trouver tous ces jeux et stocker leurs données. Stocker un jeu par atome prendrait 10 ^ 40 fois plus d'atomes que nous estimons dans l'univers observable.
Engineer Toast

6
Cette réponse est excellente jusqu'à la fin lorsque vous faites référence à un "ordinateur infiniment puissant". Ce n'est pas ce que vous voulez dire, et cette phrase n'appartient ni à la question ni à la discussion.
Don Hatch

25

Voir https://en.wikipedia.org/wiki/Endgame_tablebase .

Avec une puissance informatique infinie, on pourrait construire une telle table pour la position de départ et résoudre les échecs .

Dans la pratique, seules les positions comptant jusqu'à sept "hommes" (pions et pièces, en comptant les rois) ont été résolues à l'aide des superordinateurs actuels, nous sommes donc très loin de résoudre les échecs. La complexité du problème augmente de façon exponentielle avec le nombre de pièces.


9
En passant, si vous produisiez réellement un tel tableau, peu importe sur quoi vous stockiez les informations, il pèserait environ 10 ^ 43 fois plus que l'univers observable; considérant qu'il y a ~ 10 ^ 123 positions d'échecs possibles et seulement ~ 10 ^ 80 baryons dans l'univers observable.
Shufflepants

6
@Shufflepants qui a dit que je le stockais à l'aide de baryons?
Michael

3
@Christoph Et en supposant la conservation des informations, et en supposant que vous disposiez d'un détecteur et de votre super ordinateur avec une puissance de traitement infinie, vous pourriez lentement au cours de quelque chose comme des années googolplex lire la table comme un rayonnement de colportage.
Shufflepants

3
@Shufflepants Notez qu'une stratégie gagnante réelle peut nécessiter beaucoup moins d'espace qu'une base de table complète. Par exemple, Nim a une stratégie gagnante qui est simple à décrire, il n'est pas nécessaire de construire un immense tableau de tous les états possibles.
Federico Poloni

1
Cette solution, comme indiqué, n'est pas viable. La masse d'une telle table formerait un trou noir et il serait impossible d'en exfiltrer les données.
emory

19

Si vous aviez vraiment une puissance de traitement infinie , un tel algorithme serait en fait trivial à écrire. Comme les échecs ont un nombre fini d'états possibles, vous pouvez en théorie simplement les parcourir tous jusqu'à ce que vous trouviez un chemin de jeu parfait. Ce serait horriblement inefficace, mais si vous avez une puissance de traitement infinie , cela n'aurait pas d'importance.


Ce n'est pas vrai. Il a dit que vous avez une puissance de traitement infinie, mais n'a rien dit sur l'espace infini.
ubadub

@ubadub: Nous n'aurions pas besoin d'espace infini. La durée d'une partie est limitée en raison de la règle des 50 coups, et une règle peut être établie pour trier tous les coups possibles à partir d'une position. Comme ils peuvent être triés, ils peuvent être stockés sous forme d'entier. C'est toute la mémoire requise pour parcourir tout l'arbre. Et si vous avez un temps infini, vous pouvez marcher dans l'arbre aussi souvent que vous le souhaitez, vous n'avez donc pas à stocker toutes les parties d'échecs possibles.
vsz

La durée du jeu est limitée, mais elle est extrêmement grande; comme quelqu'un l'a souligné, si vous produisiez une table pour stocker tous ces jeux, "peu importe sur quoi vous stockiez les informations, cela pèserait environ 10 ^ 43 fois plus que l'univers observable; étant donné qu'il y a ~ 10 ^ 123 possible positions d'échecs et seulement ~ 10 ^ 80 baryons dans l'univers observable
ubadub

2
@ubadub: C'est vrai, mais je ne parlais pas d'une "table pour stocker tous ces jeux". Il existe de nombreux algorithmes liés aux arbres qui n'ont pas besoin de conserver tous les nœuds de l'arbre entier en mémoire.
vsz

@ vsz bon point
ubadub

13

Pour répondre directement à la question: oui, il existe un tel algorithme. Cela s'appelle minimax. (Les bases de table de fin de partie sont générées en utilisant cet algorithme (à l'envers!), Mais l'ancien algorithme simple minimax simple est tout ce dont vous avez besoin). Cet algorithme peut parfaitement jouer à n'importe quel jeu à somme nulle pour deux joueurs. Trouvez le pseudocode ici:

https://en.wikipedia.org/wiki/Minimax

notez que des variantes de cet algorithme sont utilisées par les programmes d'échecs informatiques modernes.


4

Non seulement existe-t-il un algorithme pour jouer aux échecs parfaits, mais il est possible d'écrire un programme court qui (étant donné des ressources infinies) jouera parfaitement à n'importe quel jeu déterministe de connaissances parfaites à durée finie à deux joueurs .

Le moteur de jeu n'a même pas besoin de connaître les règles du jeu auquel il joue. Tout ce dont il a besoin est une représentation opaque d'un "état de jeu" et des fonctions qui (a) donnent n'importe quel état de jeu, fournissent une liste des prochains états de jeu légaux et (b) donnent un état de jeu, décident si c'est une victoire pour le joueur 1 , une victoire pour le joueur 2, un match nul, ou ce n'est pas un état final.

Étant donné ces fonctions, un simple algorithme récursif "résout" le jeu.

Ce fait a été évoqué dans les réponses précédentes par chessprogrammer (minimax) et par Acccumulation (qui fournit une version du programme en python).

J'ai écrit un tel programme il y a plus de 20 ans. Je l'ai testé en jouant aux noughts-and-crosses (tic-tac-toe si vous êtes américain). Effectivement, il a joué un jeu parfait.

Bien sûr, cela tombera rapidement sur n'importe quel ordinateur imaginable pour tout jeu sérieux. Parce qu'il est récursif, il construit efficacement la totalité de l'arborescence du jeu sur la pile, vous obtiendrez donc un "débordement de pile" (jeu de mots très voulu) avant de vous approcher de l'analyse des 10 ^ 123 états d'échecs mentionnés dans d'autres réponses. Mais c'est amusant de savoir qu'en principe ce petit programme ferait l'affaire.

Pour moi, cela dit aussi quelque chose d'intéressant à propos de l'IA: quelle que soit l'intelligence que vous pensez est exposée par Deep Blue, ou Go Zero, ou bien par un humain jouant aux échecs ou à Go, il y a un sens dans lequel ces jeux ont une trivialité, une calculabilité optimale optimale solutions. Le défi est de savoir comment obtenir une bonne solution, mais pas optimale, dans un délai raisonnable.


Votre algorithme ne fonctionne que pour les jeux à deux joueurs à connaissance parfaite. Il tombera pour les jeux d'informations cachées tels que Stratego , car toute implémentation de la fonction (a) viole les règles du jeu. Il échoue également pour les jeux de durée potentiellement infinie: par exemple, supprimez la règle des 50 coups des échecs, et cela ne peut pas dire que deux rois se poursuivant autour du plateau ne sont pas un état gagnable. Tout ce qu'il peut dire, c'est que ce n'est pas un état final.
Mark

Points valides. Je vais modifier ma réponse.
gareth

3

J'ignorerai les possibilités de tirages ou de séquences infinies de mouvements pour plus de simplicité. Une fois l'algorithme compris, il n'est pas particulièrement difficile de l'étendre à ces cas.

Tout d'abord, quelques définitions:

  1. Tout coup qui gagne la partie pour le joueur qui fait ce coup est un coup gagnant.

  2. Tout coup qui perd la partie pour le joueur qui fait ce coup est un coup perdant.

  3. Tout coup qui laisse à l'autre joueur au moins un coup gagnant est également un coup perdu. (Puisque l'adversaire peut prendre ce mouvement et forcer une perte.)

  4. Tout coup qui laisse l'autre joueur avec seulement des coups perdus est également un coup gagnant. (Peu importe le mouvement de votre adversaire, vous gagnerez.)

  5. Une stratégie parfaite signifie toujours faire des coups gagnants s'il en reste et démissionner quand il ne reste plus que des coups perdants.

Maintenant, il est trivial d'écrire une stratégie parfaite. Explosez simplement toutes les séquences de mouvements possibles et identifiez les mouvements gagnants / perdants. Ignorant l'impasse, cela finira par identifier chaque coup comme un coup gagnant ou un coup perdant.

Maintenant, la stratégie est triviale. Regardez tous vos mouvements possibles. S'il reste des coups gagnants, prenez-en un et gagnez. S'il ne reste que des coups perdants, démissionnez, car votre adversaire peut vous forcer à perdre.

Il n'est pas difficile d'ajuster la stratégie pour inclure la possibilité d'une impasse.

Mise à jour : juste au cas où il n'est pas clair comment cela identifie chaque mouvement comme un gain gagnant ou un coup perdant, considérez:

  1. Chaque coup qui donne lieu à une victoire est un coup gagnant.
  2. Chaque coup qui entraîne une perte est un coup perdu.
  3. Chaque coup qui fait que l'adversaire n'a que des coups gagnants ou perdants est un coup gagnant ou un coup perdu.
  4. Appelez nle nombre de coups dans la partie d'échecs la plus longue possible. (Nous ignorons les séquences illimitées pour l'instant, bien que les inclure ne soit pas difficile.)
  5. Il n'y a aucun mouvement avec ndes mouvements antérieurs que nous devons considérer.
  6. Chaque coup avec n-1des coups précédents est soit un coup gagnant, soit un coup perdu puisque les ncoups mettent fin à la partie la plus longue.
  7. Ainsi, chaque coup en profondeur n-2est suivi uniquement de coups gagnants ou de coups perdus et est donc lui-même un coup gagnant ou un coup perdu.
  8. Et ainsi de suite jusqu'au premier coup.

1
Vos définitions des mouvements gagnants et perdants ne sont pas assez complètes. Le premier coup, par exemple, ne gagne pas la partie (# 1), ni ne laisse l'adversaire avec seulement des coups perdus (# 4), donc ce n'est pas un "coup gagnant". Il ne perd pas non plus le jeu (# 2), ni ne laisse l'adversaire avec un coup gagnant (# 3), donc ce n'est pas un "coup perdu". Votre stratégie exige que chaque coup soit défini comme un «coup gagnant» ou un «coup perdant», ce qui n'est tout simplement pas le cas tel que vous l'avez défini.
Nuclear Wang

2
@NuclearWang Il définit chaque coup comme un coup gagnant ou un coup perdant. Selon vous, quelle est la troisième alternative? Visualisez l'arborescence de toutes les parties d'échecs possibles (et rappelez-vous, nous excluons les liens ou les séquences infinies pour l'instant). Chaque chaîne se termine par une victoire ou une perte. Cela s'infiltre à travers l'arbre et finit par identifier chaque mouvement comme un mouvement gagnant ou un mouvement perdant.
David Schwartz

13
@NuclearWang soit le premier coup est un coup gagnant pour un joueur, soit les échecs sont (comme le tic-tac-toe) un jeu dessiné avec un jeu parfait. Nous ne savons pas quoi parce que personne n'a jamais eu la puissance de calcul pour exécuter cet algorithme jusqu'à son terme, et personne n'a trouvé de preuve plus directe.
hobbs

8
Il n'y a aucun hasard et aucune information cachée dans les échecs, ce qui ne laisse aucune place à "peut-être". Chaque position est gagnée, perdue ou tirée (même si nous n'avons pas réussi à les identifier comme tels). Et cette explication laisse de côté l'option "tirée" pour plus de simplicité, mais elle revient principalement à 1) une position est tirée si elle est tirée conformément aux règles, et 2) une position est tirée si elle n'a pas de coups gagnants, mais a au moins au moins un coup qui laisse l' adversaire sans coups gagnants.
hobbs

2
@DavidSchwartz: Sauf si quelqu'un est en position de perdant, chaque mouvement qui n'est pas parfait est mauvais. Dans une position perdante, il n'y aurait généralement pas de mouvement "parfait" unique [sauf dans une situation de mouvement forcé] car tout mouvement légal pourrait avoir une certaine probabilité d'être le seul mouvement gagnant ou nul dans certaines circonstances imaginables (peut-être très artificielles). Démissionner, cependant, semblerait être le pire "mouvement" sans ambiguïté. Supposons que le jeu soit prouvé comme une victoire pour les Blancs avec d4. Souhaitez-vous jouer à un programme d'échecs qui a répondu 1. d4avec ...resigns?
supercat

2

Supposons que vous avez trois fonctions: win_state, get_playeret next_states. L'entrée pour win_stateest un état de jeu, et la sortie est -1 si le blanc est en échec et mat, 0 s'il s'agit d'un match nul, 1 si le noir est en échec et Noneautre. L'entrée pour get_playerest un état de jeu, et la sortie est -1 si c'est le tour du noir et 1 si c'est le tour du blanc. L'entrée pour next_statesest une liste des états possibles du prochain jeu qui peuvent résulter d'un mouvement légal. Ensuite, la fonction suivante, lorsqu'elle reçoit un état de jeu et un joueur, devrait vous dire dans quel état de jeu se déplacer pour que ce joueur gagne.

def best_state(game_state,player)
  def best_result(game_state):
     if win_state(game_state):
        return(win_state)
     else:
         player = get_player(game_state)
         return max([best_result(move)*player for move in next_states(game_state)])*player
  cur_best_move = next_states(games_state)[0]
  cur_best_outcome = -1
  for state in next_states(game_state):
     if best_result(state)*player > cur_best_outcome:
           cur_best_outcome = best_result(state)*player
           cur_best_move = state
return(best_move)

0

Utiliser une table de correspondance

Oui. C'est facile. Vous n'avez même pas besoin d'une puissance de traitement infinie. Tout ce dont vous avez besoin est une table de consultation qui contient, pour chaque position de plateau possible, le meilleur coup à jouer dans cette position. Voici le pseudo-code:

def play-move(my-color, board-position):
    return table-of-best-moves[my-color, board-position]

La prise

Le seul hic, c'est que cette table de correspondance devrait être très, très grande - peut-être plus grande que la galaxie de la Voie lactée - et il faudrait beaucoup de temps pour la construire - peut-être plus longtemps que l'âge actuel de l'univers, à moins qu'il n'y ait une régularité inconnue dans les échecs qui le rend beaucoup plus simple que ce que nous pouvons voir en ce moment. Mais si vous aviez cette table de recherche, le sous-programme pour choisir un mouvement parfait à chaque fois pourrait être implémenté en aussi peu qu'une instruction CPU.

De plus, étant donné nos connaissances actuelles sur les échecs, il n'y a aucun moyen d'être sûr qu'un jeu parfait garantit que vous ne perdrez pas. Par exemple, si un jeu parfait garantit une victoire pour les Blancs, alors les Noirs perdraient même si les Noirs jouent parfaitement.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.