¿Quién ganará el Candidatos? Simulando el torneo con Python.

En esta publicación vamos a ver como simular un torneo de ajedrez, en este caso el Torneo de Candidatos, y a ver que nos dicen las simulaciones acerca de quien es el favorito, más allá de "el que más elo tiene".

Todos sabemos que el elo no es lo único que importa, el estilo es algo importante, y hay jugadores con más elo que suelen perder contra gente de menos elo, simplemente porque se le da bien jugar contra el estilo del oponente, o porque conoce mejor las aperturas que se dan, porque sabe como llevarle a posiciones donde juega peor.

Quitando los extremos (Caruana y Alekseenko), los otros 6 están entre 2805 (Liren) y 2763 (Hao). Según las matemáticas en las que se basa el rating de elo, Liren le ganará a Hao apenas el 56% de los puntos, es decir, hay muchísima igualdad.

Como estoy aprendiendo a programar en Python, me propuse crear un programa que me diera las probabilidades de cada candidato de ganar el torneo, iré paso por paso:

1. Cómo calcular las probabilidades de ganar
2. Cómo simular los torneos
3. Cómo calcular las probabilidades de cada encuentro
4. Cómo realizar los desempates

Los que no estéis interesados en la parte de programación podéis saltar al final para ver los resultados

Cómo calcular las probabilidades de ganar el torneo

Esto era relativamente fácil, la idea es contar el número de torneos ganados de cada uno y dividirlo entre el número de torneos simulados. Si se simulan 1000 torneos, y Caruana gana 200, pues la probabilidad sería de 20%.

Cómo simular los torneos

Para simular un torneo, debemos hacer jugar a los jugadores entre ellos, todos contra todos, 2 veces (ida y vuelta). Eso se hace con un bucle for doble, que recorra la lista de los 8 jugadores, y haga enfrentar a cada uno con todos los de la lista de 8 jugadores, menos contra sí mismo (obvio  ). Para ello incluiremos un condicional, "if", que descarte el caso que el jugador "x" se enfrenta contra el jugador "x". Para calcular el resultado de cada partida, tenemos la función de la biblioteca numpy, random.choice, un generador de selección aleatoria.

Con esta función, tenemos que por ejemplo:

np.random.choice(["Caruana","empate","Liren"],size=1,p=[0.3,0.5,0.2])

Nos devolvería un valor (size=1) entre Caruana, empate y Liren, según las probabilidades dadas. Es decir, lo más probable sería el empate (0.5), seguido de Caruana (0.3) y de Liren (0.2). Si en vez de size=1, pusiera size=2, nos daría 2 resultados, por ejemplo: ["Caruana", "empate"]. Pero en mi caso preferí simular partida a partida.

A continuación se suman los puntos ganados a cada jugador, con un simple contador (básicamente, PtsjugadorX=PtsjugadorX+vicsjugadorX+empate/2)

Cómo calcular las probabilidades de cada encuentro

Como hemos visto, la función random.choice nos pide probabilidades. Aquí se complica el asunto, ya que no hay forma objetiva de saber las probabilidades de ganar/empatar/perder entre 2 jugadores.

Tuve en cuenta los resultados particulares de los últimos años, ya que la mayoría tiene muchas partidas entre ellos (por ejemplo Caruana y Giri tienen 30 partidas, la mayoría los últimos 4 años). En el caso de que no hubiera muchas partidas, tuve en cuenta el resultado de convertir el elo en probabilidades, como ya vimos (la mayoría de estas probabilidades corresponden a Alekseenko).

Cómo realizar los desempates

Para los desempates me tomé alguna libertad. El primer desempate es resultado particular, pero eso requiere más trabajo del que quería hacer  Así que simplemente les hago jugar un match a los jugadores que hayan empatado (da igual que sean 2 o más). En caso de empate en ese match, paso al 2º desempate: número total de victorias, lo cual implica que debo guardar además de los puntos, las victorias:

vicsjugadorX=vicsjugadorX+vicsjugadorX

El resultado

Resultado con Radjabov:

Tras poner al programa a simular 500000 torneos (aproximadamente 1 hora), los resultados son los siguientes:

Caruana: -----------30.84 %

Liren: ---------------30.08 %

Giri: -----------------15.12 %

Nepomniachtchi: ---7.55 %

Radjabov:-----------7.32 %

Grischuk: -----------4.55%

Hao: ----------------4.19 %

Alekseenko: ---------0.35%

Por lo que como indicaba el elo, Caruana es el favorito, pero prácticamente con el mismo porcentaje se encuentra Liren, y Giri también tiene sus opciones (entre los 3 suman 76%), especialmente si transforma algunas de esas tablas que suele hacer, en victorias. En el otro lado esta Alekseenko, con opciones mínimas, y al que todos intentarán ganar, ya que el que no le gane tendrá desventaja.

Probablemente Liren esté tan arriba gracias a Hao y a Nepo, contra los que tiene mejores oportunidades que Caruana, mientras que el duelo Caruana-Liren está igualado. En cambio Giri está con un 15% gracias a todas las tablas que hace, y a sus pocas derrotas.

Actualización tras la entrada de MVL en sustitución de Radjabov:

Caruana: -----------25.73 %

Liren: ---------------25.66 %

Giri: -----------------18.40 %

MVL:-----------13.49 %

Nepomniachtchi: ---7.55 %

Hao: ----------------4.14 %

Grischuk: -----------3.70%

Alekseenko: ---------0.34%

Ahora el torneo está mucho más igualado. Liren y Caruana siguen de favoritos, pero han perdido un 5% cada uno. MVL obtiene más de un 13%, y el gran beneficiado es Giri, que sube un 3%, quedando con un 18%. Entre los 4 mejores suman ya casi 85%.

El programa:

Como es complicado pegar el código en el blog de chess.com, lo dejo en imágenes, para demostrar que sí que lo hice  las probabilidades las he cambiado un poco, ya que los elos han cambiado y tuve que recalcularlos. Podéis abrir las imágenes en una pestaña nueva para verlas más grandes.