Chess AI: Alpha Beta vs Monte Carlo

This project explores the foundations of chess AI by implementing and comparing two fundamental algorithms: Alpha Beta Pruning and Monte Carlo Tree Search (MCTS), without any neural network assistance.

Live Demo

Try the chess engine yourself: chess.appliedtensors.com

Play against the AI or watch algorithms compete against each other in real-time.

Motivation

Inspired by Google DeepMind's AlphaZero, which famously defeated Stockfish using MCTS combined with deep neural networks, this project asks: What can these algorithms do on their own, without machine learning?

By stripping away the neural network, we can clearly see the strengths and limitations of each approach in their pure form.

The Algorithms

Alpha Beta Pruning

Alpha Beta Pruning works by looking ahead at possible moves while maintaining bounds on the best result each player can guarantee. When it encounters a branch that cannot improve on what's already known, it prunes (skips) that entire subtree.

Characteristics:

• Methodical and exhaustive within its search depth
• Highly efficient through strategic pruning
• Deterministic - same position always produces same move
• Performance scales with search depth (exponential)

Monte Carlo Tree Search

MCTS works by simulating many random game playouts from the current position. It learns which moves tend to lead to better outcomes and gradually focuses computational effort on the most promising paths.

Characteristics:

• Probabilistic - uses random simulations
• Scales with number of simulations
• Without neural network guidance, relies on random playouts
• In chess, random moves often lead to blunders

Key Findings

Through extensive testing, Alpha Beta Pruning consistently outperforms pure MCTS in this implementation. Here's why:

Alpha Beta's Advantage:

• Chess is a deterministic, perfect-information game
• Exhaustive search within depth guarantees optimal play at that depth
• Pruning eliminates bad branches without sacrificing quality
• No randomness means no accidental blunders

MCTS Without Neural Networks:

• Random playouts in chess are low-quality
• Random moves frequently blunder pieces
• Simulations don't teach the algorithm what "good chess" looks like
• Needs many more simulations to overcome noise from random play

Why AlphaZero Works:

AlphaZero doesn't use MCTS alone. It combines MCTS with a deep neural network that:

1. Guides simulations - suggests which moves are worth exploring
2. Evaluates positions - provides informed position assessments
3. Eliminates randomness - replaces random playouts with learned intuition

The neural network transforms MCTS from "dart throwing" into strategic exploration.

Technical Implementation

The project features:

• Adjustable depth control for Alpha Beta (affects search thoroughness)
• Simulation count slider for MCTS (affects convergence quality)
• Real-time heatmap showing move confidence levels (lighter = more confident)
• Statistics panel displaying:
  • Search depth
  • Position evaluation (centipawn advantage)
  • Nodes searched
  • Branches pruned (for Alpha Beta)
  • Computation time

Demo Video

Watch the full algorithm comparison: youtu.be/QoccSHU-TYI

The video demonstrates both algorithms in action, shows algorithm-vs-algorithm matches, and explains why neural networks are crucial for modern chess AI.