Skip to content
TheChatArchiveThe Chat Archive
grok-3-mini-beta· xAIHugging Face LMArena Human Preference 140K

A common mentioned value for possible chess games is 10^120 . But what about reasonable…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-3-7-sonnet-20250219’s answer.
  1. User

    A common mentioned value for possible chess games is 10^120 . But what about reasonable (competitive) games? Consider the average branching factor and the average length, or any other important factor to make estimates. Could you come up with a reasonable estimate?

    As a bonus, what is the average branching factor that chess engines consider?

  2. Assistant

    Below, I'll address your query step by step. First, I'll explain the context of the common estimate of 10^120 for all possible chess games (the Shannon number). Then, I'll focus on estimating the number of "reasonable (competitive)" games, considering factors like the average branching factor, game length, and other important elements. Finally, I'll cover the bonus question about the average branching factor that chess engines consider.

    1. Context: The Total Number of Possible Chess Games

    The figure of 10^120, proposed by Claude Shannon in his 1950 paper, represents an estimate for the total number of possible chess games, including all legal sequences of moves from the starting position until checkmate, stalemate, or a draw. This includes:

    • Games of any length (though most end within 80-100 moves).
    • Every possible legal move at each turn, leading to an enormous game tree.

    Shannon based this on an average branching factor of about 30-35 legal moves per position and an average game length of around 40 moves per player (80 plies, where a ply is one player's move). The calculation is roughly:
    Number of games ≈ (average branching factor)^(average game length in plies)
    For example: 35^80 ≈ 10^120.

    However, this includes many absurd or non-competitive sequences, like games where players make random or blundering moves. For "reasonable (competitive)" games—those played at a high level, such as between grandmasters or strong engines—we need to refine this estimate by focusing on plausible, strategic play.

    2. Estimating the Number of Reasonable (Competitive) Games

    To estimate the number of competitive games, we must account for the fact that strong players don't explore the full game tree. Instead, they limit themselves to high-quality moves based on opening theory, middlegame principles, and endgame technique. This reduces the effective branching factor and imposes other constraints.

    Key Factors to Consider:

    • Average Branching Factor: In the full game tree, the branching factor is about 35 (the average number of legal moves per position). However, for competitive play:

      • Players typically consider only a subset of "candidate moves" that align with strategic goals (e.g., developing pieces, controlling the center, or creating threats).
      • A reasonable estimate for competitive games might be an effective branching factor of 5-10 per ply. This is based on studies of grandmaster games, where the average number of plausible moves at each turn is much lower than the total legal moves. For instance:
        • In the opening, players often follow established lines, limiting choices to 2-5 moves.
        • In the middlegame, strategic depth might allow 5-10 viable options.
        • In the endgame, precision reduces it further.
    • Average Game Length: Competitive games are typically shorter and more efficient than the theoretical average. Tournament games often last 40-60 moves per player (80-120 plies), but many end earlier due to resignations, draws, or checkmates. For estimation, let's use 80 plies as a baseline, as this aligns with Shannon's original figure and is common in high-level play.

    • Other Important Factors:

      • Opening Constraints: Most competitive games start with a limited set of openings (e.g., from the 500-1,000 most common ones in databases like ChessBase). This drastically reduces the initial branches.
      • Draws and Repetition: Many games end in draws (e.g., via threefold repetition or the 50-move rule), which limits the total unique outcomes.
      • Transpositions and Symmetry: Many move sequences lead to the same position (due to transpositions), so the actual number of distinct games is lower.
      • Human/Engine Pruning: In practice, strong players or engines avoid blunders, so only "sound" lines are considered. This is similar to how engines use alpha-beta pruning (more on this in the bonus section).
      • Database Evidence: Real-world data from chess databases (e.g., millions of games from FIDE tournaments) shows that only a tiny fraction of the theoretical 10^120 games have been played. For example, there are about 1 million unique games in major databases, but this is just a sample of competitive play.

    My Estimate for Reasonable (Competitive) Games:

    Using the formula from earlier—Number of games ≈ (effective branching factor)^(average game length)—but with adjustments for competitive play:

    • Assume an effective branching factor of 7 (a middle-ground estimate for high-level games, based on analyses of grandmaster move selection).
    • Assume an average game length of 80 plies.

    The calculation would be:
    7^80 ≈ 10^(80 * log10(7)) ≈ 10^(80 * 0.845) ≈ 10^67.6, or roughly 10^68.

    However, this is still an overestimate because it doesn't fully account for the constraints above. A more realistic estimate for "plausible competitive games" (e.g., those that could arise in games between 2500+ rated players) might be in the range of 10^40 to 10^60. Here's why:

    • Why lower?: If we factor in opening limitations (e.g., only 10^6 possible opening sequences are commonly played) and the tendency for games to converge on known patterns, the effective number drops significantly. Some chess theorists (e.g., in discussions of game complexity) suggest that the number of "interesting" or high-quality games is around 10^40-10^50, as this aligns with the diversity seen in tournament databases.
    • Upper bound: 10^60 might represent games up to a professional level, including variations.
    • Lower bound: 10^40 could be for elite grandmaster games, where moves are even more constrained.

    In summary, while the total possible games are 10^120, the number of reasonable competitive games is likely between 10^40 and 10^60. This is a rough, heuristic estimate based on reducing the branching factor and game length while considering real-world patterns. It's not exact, as chess is too complex for precise counts, but it gives a sense of the scale: still astronomically large, but far smaller than the full Shannon number.

    3. Bonus: Average Branching Factor That Chess Engines Consider

    Chess engines like Stockfish or AlphaZero don't evaluate the full branching factor of 35 per ply because that would be computationally infeasible. Instead, they use search algorithms to prune the tree dramatically.

    • Theoretical vs. Effective Branching Factor:

      • The raw branching factor in chess is about 35, as mentioned.
      • However, engines use techniques like:
        • Alpha-beta pruning: This eliminates branches that won't affect the best move, reducing the effective factor to 2-5 per level in practice.
        • Move ordering: Engines prioritize promising moves (e.g., captures or checks), so they often evaluate only the top few candidates first.
        • Transposition tables and caching: These avoid re-evaluating identical positions.
        • Evaluation functions: Engines quickly dismiss bad moves based on heuristics.
    • Average Branching Factor for Engines:

      • For modern engines, the effective branching factor during a search is typically 2-5 nodes per ply, depending on the depth and position.
        • At shallow depths (e.g., 1-5 plies), it might be closer to 5-10 because the engine hasn't pruned much yet.
        • At deeper depths (e.g., 10-20 plies in a full search), it drops to 2-3 due to efficient pruning.
      • For example, Stockfish might evaluate only 1-2 million positions per second on a typical CPU, but with alpha-beta, it effectively explores a tree with a branching factor of about 3 for a search depth of 20-30 plies.
      • Neural-network-based engines like AlphaZero further reduce this by focusing on policy networks that predict only the most promising moves, effectively lowering the branching factor to 1-2 in their initial move selection.

    In essence, while the game tree has a nominal branching factor of 35, chess engines operate with an effective branching factor of around 3-5 for most practical searches. This is why they can analyze deep positions without exponential blowup.

    If you have more details (e.g., specific engine or depth), I could refine this further!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.