Quando vi essa troca de farpas entre Elon Musk e o Chess.com, segundo o Sapo.pt, a primeira coisa que pensei não foi em xadrez — foi em como devs confundem “IA forte” com “IA que resolve tudo”. A afirmação do Musk é provocativa, mas tecnicamente errada em vários sentidos. E é justamente por isso que vale a pena destrinchar o assunto, porque no fundo estamos falando de combinatória, complexidade computacional e do estado real da arte em busca em árvore.
Por que “resolver” o xadrez é praticamente impossível
O número de posições legais únicas de xadrez é estimado em torno de 4,8 × 1044. Parece muito, e é. Mas o número de jogos possíveis é ainda mais absurdo: cerca de 10120. Isso é mais do que o número de átomos no universo observável (estimado em 1080). Não estou exagerando — é literalmente mais do que existe matéria para você “guardar” o resultado.
Na minha experiência modelando sistemas de busca, o que mais engana devs é confundir a capacidade de uma IA jogar bem com a capacidade de uma IA resolver o jogo. São problemas radicalmente diferentes. Jogar bem é encontrar boas jogadas em posições específicas. Resolver o jogo é provar matematicamente o resultado de cada posição possível, assumindo jogo perfeito de ambos os lados.
O que significa, de fato, “resolver” um jogo?
Aqui entra uma distinção técnica que pouca gente faz, mas que separa engenheiros de curiosos:
- Solução ultrafraca: determina apenas se o primeiro jogador vence, perde ou empata com jogo perfeito — sem mostrar a linha.
- Solução fraca: fornece uma estratégia para o primeiro jogador a partir da posição inicial que garante o resultado ótimo.
- Solução forte: resolve toda posição legal do jogo. Para cada uma, indica o resultado ótimo.
O Connect Four foi o primeiro jogo resolvido por um computador (1988). O jogo da velha é trivial. Damas foi resolvido em 2007 pela equipe de Jonathan Schaeffer — e levou 18 anos de pesquisa. Mas o xadrez? Só temos tablebases completas até 7 peças (Lomonosov tablebases, mantidas pela Universidade de Michigan). Acima disso, o espaço de estados explode de forma combinatória.
Tablebases: o pedaço do xadrez que já está resolvido
As tablebases são, na prática, bancos de dados gigantes que armazenam o resultado de cada posição com N peças. Quando o Stockfish entra em final com 7 ou menos peças, ele “desliga” o pensamento e simplesmente consulta a tablebase. Isso é engenharia pura — não envolve rede neural, não envolve aprendizado. É lookup.
Se você já trabalhou com sistemas que misturam heurística e lookup determinístico, sabe como esse padrão é elegante. Para a maioria dos problemas de produção, a melhor solução não é “mais IA” — é saber quando parar de pensar e consultar uma base conhecida.
Engines modernas: muito além do “computador pensa melhor”
A discussão do Musk no X ignora propositalmente como uma engine moderna realmente funciona. Hoje, o estado da arte em xadrez combina duas abordagens:
Alpha-Beta + avaliação heurística (Stockfish)
O Stockfish faz busca alpha-beta com poda — basicamente uma árvore de decisões onde ramos piores que os já encontrados são cortados. Acrescenta-se NNUE (Neural Network Unified Evaluation), uma rede neural eficiente que substituiu a antiga tabela de avaliação feita à mão. Resultado: mais de 3800 ELO.
MCTS + redes neurais profundas (Leela Chess Zero)
Inspirado no AlphaGo e AlphaZero do DeepMind, o Leela usa Monte Carlo Tree Search combinado com uma rede neural que avalia posições e prediz políticas. A diferença é filosófica: em vez de explorar exaustivamente com heurísticas humanas, ele simula partidas e aprende com reinforcement learning.
O argumento técnico que o Musk ignorou
Quando ele diz que “o xadrez é simples para computadores”, está certo na superfície, mas erra no conceito. As engines jogam melhor que qualquer humano. Isso é fato. Mas “resolver” o jogo exigiria força bruta combinatória que nenhum hardware atual — nem o projected do em 50 anos — consegue entregar. Não é limitação de software. É termodinâmica. A entropia do problema excede a capacidade de qualquer sistema físico realista.
Na Prática: implementando um MCTS simplificado em Python
Para quem quer entender o coração de uma engine moderna, nada melhor que colocar a mão no código. Abaixo está uma implementação enxuta do loop principal do MCTS, do tipo que aparece no Leela e no AlphaZero:
import math
import random
from collections import defaultdict
class Node:
def __init__(self, state, parent=None):
self.state = state # estado do jogo
self.parent = parent
self.children = {}
self.visits = 0
self.wins = 0.0
self.untried_moves = state.legal_moves()
def ucb1(self, exploration=1.41):
if self.visits == 0:
return float('inf')
return (self.wins / self.visits) +
exploration * math.sqrt(math.log(self.parent.visits) / self.visits)
def best_child(self):
return max(self.children.values(), key=lambda n: n.ucb1())
def expand(self):
move = self.untried_moves.pop()
next_state = self.state.apply(move)
child = Node(next_state, parent=self)
self.children[move] = child
return child
def rollout(self):
state = self.state.clone()
while not state.is_terminal():
state.apply(random.choice(state.legal_moves()))
return state.result() # 1, 0 ou 0.5
def backpropagate(self, result):
while self is not None:
self.visits += 1
self.wins += result
result = 1 - result # alterna perspectiva
self = self.parent
def mcts(root_state, itermax=1000):
root = Node(root_state)
for _ in range(itermax):
node = root
# 1) Selection
while node.untried_moves == [] and node.children:
node = node.best_child()
# 2) Expansion
if node.untried_moves:
node = node.expand()
# 3) Simulation
result = node.rollout() if not node.state.is_terminal() else node.state.result()
# 4) Backpropagation
node.backpropagate(result)
return root.best_child().state.last_move()
Esse é o esqueleto do algoritmo que destronou Kasparov. Quatro etapas: seleção (escolhe o melhor nó via UCB1), expansão (adiciona um novo movimento), simulação (joga até o fim aleatoriamente — o “playout”), e retropropagação (atualiza estatísticas). Quando você substitui o rollout aleatório por uma rede neural avaliando a posição, você tem o AlphaZero. Quando substitui a política uniforme por uma rede que sugere movimentos, você tem o Leela.
Recomendo rodar isso em um jogo simples como Connect Four ou jogo da velha primeiro — em xadrez puro, cada chamada vai te custar ordens de grandeza a mais de CPU.
Erros comuns que devs cometem ao falar de “IA que resolve tudo”
Depois de anos vendo gente confundir capacidade computacional com onisciência, listei os equívocos mais frequentes:
- Achar que “jogar bem” é o mesmo que “resolver”. Não é. Stockfish joga acima de qualquer humano, mas não tem ideia do que acontece na posição 8 peças depois do início do jogo.
- Confundir escala exponencial com escala polinomial. Xadrez não escala “um pouquinho mais difícil” — escala combinatorialmente. Dobrar o horizonte de busca dobra a árvore, mas dobrar a profundidade multiplica.
- Subestimar o papel da avaliação humana. Por décadas, engines usaram regras escritas à mão por grandes mestres. NNUE mostrou que dá pra fazer melhor com redes neurais, mas isso ainda é engenharia, não magia.
- Achar que mais dados resolvem tudo. Em xadrez, dados não faltam — temos bilhões de partidas. O gargalo é busca, não dados.
- Generalizar do xadrez para a inteligência geral. Xadrez é um jogo de informação perfeita, dois jogadores, soma zero. Generalizar disso para “IA vai resolver tudo” é o mesmo erro de quem acha que resolver CAPTCHA significa que a máquina “entende” imagens.
Cuidado com a armadilha retórica do Musk: ele é brilhante em marketing e fraco em nuance técnica. Quando ele fala em “resolver” xadrez, está usando o termo no sentido coloquial — “uma IA joga perfeitamente”. Mas isso já existe. O sentido forte, matemático, está a décadas de distância.
O que isso significa para quem trabalha com IA no dia a dia
A lição que eu levo desses debates inflados é uma só: contextualize antes de empolgar. Quando alguém te vender “IA que resolve X”, pergunte:
- Resolve no sentido fraco ou forte?
- Qual o espaço de busca do problema?
- A solução é por busca exaustiva, heurística ou aprendizado?
- O resultado é garantido matematicamente ou apenas provável?
Essas perguntas separam quem entende do assunto de quem só reproduz hype. Testei isso em produção em sistemas de recomendação e detecção de fraude: a maioria dos problemas não tem “solução” — tem soluções boas o suficiente dentro de uma margem aceitável. Xadrez não está nessa categoria justamente porque queremos perfeição, e perfeição combinatória é cara.
FAQ — Perguntas que devs realmente fazem
1. Xadrez já foi resolvido, mesmo?
Não no sentido forte. Apenas posições com até 7 peças estão completamente resolvidas via tablebases. A posição inicial do jogo continua sem solução formal conhecida.
2. Por que o AlphaZero é considerado uma revolução se já existiam engines fortes?
Porque o AlphaZero aprendeu do zero, apenas conhecendo as regras, sem base de dados de partidas humanas, e atingiu nível sobre-humano em poucas horas de treinamento. Eliminou décadas de ajuste humano manual.
3. Computador quântico resolve xadrez?
Em teoria, oferece aceleração quadrática para busca em árvore não estruturada (algoritmo de Grover). Mas o gargalo do xadrez não é busca pura — é o tamanho absurdo do espaço de estados. Ganho quadrático em 10120 ainda é… muito grande.
4. Dá pra rodar uma engine forte em hardware modesto hoje?
Sim. Stockfish roda em laptops comuns com NNUE. Para neural networks tipo Leela, você precisa de GPU decente, mas até placas de entrada dão conta em nível de mestre.
5. O que essa história toda ensina sobre avaliar hype de IA?
Que afirmações grandiosas sem definição de termos são red flags. “Resolver”, “entender”, “criar” — cada um significa coisas radicalmente diferentes quando você põe sob escrutínio técnico.
No fim das contas, Musk acertou num ponto que devíamos levar a sério: a IA vence humanos no xadrez há décadas e vai continuar vencendo. Mas “resolver” o jogo? Isso é outro departamento — um departamento que a humanidade talvez nunca inaugure. E tá tudo bem. Nem toda pergunta precisa de resposta finita para ter valor.
Gostou? Me segue no GitHub e deixa um comentário se tiver dúvida ou quiser aprofundar algum ponto.