Try Opera Browser here! https://opr.as/Opera-browser-twoswap

If you liked this, please support me on Patreon! / 2swap
You can support the musician, 6884, on Kofi: https://ko-fi.com/iam6884
Check out his music here! https://6884.bandcamp.com/
This video was rendered using SwapTube! https://github.com/2swap/swaptube
Want to practice your Connect 4 skills? Join the 2swap discord! / discord

Sources:
Allis (1988): A Knowledge-based Approach of Connect-Four / https://tromp.github.io/c4/connect4_t...
Böck (2025): Strongly Solving 7x6 Connect-Four on Consumer Grade Hardware / https://arxiv.org/abs/2507.05267
Allen (2010): The Complete Book of Connect 4 / https://a.co/d/06OC1kW3
John Tromp's 'fhourstones' was used extensively in search. https://tromp.github.io/c4/fhour.html
A big thank you to CTL560 who found a whole lot of steady states by hand!

Play with the solution yourself! https://2swap.github.io/WeakC4/
Writeup of technical details at: https://2swap.github.io/WeakC4/explan...
Anki flashcard deck: https://ankiweb.net/shared/info/17788...

Connect 4 is fully solved: perfect play on the standard 7×6 board gives red (player 1) a forced win by opening in the center, and the video shows how to compress that complete perfect-play map into a small, human-usable graph plus endgame “cheat sheets.”youtube

Very brief summary

The creator explains classical strong solutions for Connect 4 (huge game trees computed by Allen and Allis) and why they are unusable for humans. He then constructs a weak solution by pruning blunders and duplicate winning lines, finds “steady-state” endgame diagrams that act as small programs for perfect play, and stitches these into a compressed opening graph of about 4,550 nodes that fully encodes perfect play for red. Finally, he uses this to reflect on emergent complexity: simple rules can generate strategic landscapes so rich they cannot be captured by a short explanation, much like clouds emerging from basic physics.youtube

Very brief outline

• Gods-eye view and classical solution: omniscient “gods” and 1988 strong solutions prove red wins by opening in the center.youtube

• Exponential game tree and hybrid approach: contrast brute force vs memorization and motivate memorized openings plus endgame search.youtube

• From strong to weak solutions: build the full tree, prune losing moves and redundant wins to get a minimal perfect-play tree.youtube

• Steady-state diagrams: define 8-rule “cheat sheets” that encode perfect endgames as small programs instead of huge subtrees.youtube

• Compressed opening graph: attach steady states to a pruned, symmetry-merged opening tree to get a 4,550-node map of all perfect openings.youtube

• Difficulty of openings: interpret long vs short branches as challenging vs easy yellow replies, highlighting lines like “one off center” and candlesticks.youtube

• Emergent complexity: connect the Connect 4 solution to broader ideas about complexity arising from simple rules, using clouds and weather as analogies.youtube

Detailed outline of the video

• Perfect-play overview and “map of Connect 4”

  • Shows a big graph where each branch is an opening tree under perfect play, some long and forced, some dense with variations.00:00

  • Asks how such a solution can be created in a way that fits in a small, human-usable graph.00:30

• Gods-eye solution and classical computer results

  • Imagines two omniscient “gods” playing perfectly; red discovers that only a center first move wins, near-center draws, and side openings lose.00:47

  • Notes that perfect-play first-player win was proved by Allen and Allis (1988) using huge brute-force searches.01:30

• Human problem: why and how to play, not just “center wins”

  • Raises questions: which yellow replies are most challenging, whether yellow should mirror in center or play sideways, and how humans can maintain the P1 advantage vs perfect defense.01:58

  • Introduces the goal: a simpler, human-memorizable perfect strategy, small enough to display as a graph.02:41

• Search vs memorization and the exponential blowup

  • Compares two extremes: brute-force search (high compute, low memory) vs full opening-book memorization (huge memory, almost no thinking at game time).03:00

  • Quantifies growth: 1 empty position, 7 first moves, 49 positions after two plies, thousands after 5 moves, millions near move 10, giving an exponential curve of positions to memorize.03:39

• Hybrid “strong solution” approach (Allis-style)

  • Shows that after some midgame depth, brute-forcing from there is cheaper than from the start, so you can memorize openings and then search the endgame.04:09

  • Describes Victor Allis’s 1988 solution: ~500k perfect-opening positions plus a fast endgame solver—still far beyond what humans can memorize.05:06

• From strong to weak solutions by pruning

  • Defines the full strong solution tree: all legal positions up to some depth, including lines where red already blundered.05:27

  • Prunes losing first moves (like opening on the extreme side) because a perfect red would never play them, shrinking the tree.05:48

  • Further prunes duplicate winning choices: if two moves both win, keep only one representative, yielding a weak solution tree that still encodes perfect play but with fewer branches.06:16

• Multiple weak trees and the idea of “patterny” weak solutions

  • Shows that depending on which winning option you keep (always leftmost, always rightmost, random), you get different-looking weak solution trees, from messy to very structured “pillow” shapes.07:41

  • Poses the challenge: how to systematically find the “patterny” weak solution with lots of regularity and compressibility.08:05

• Steady-state diagrams (endgame cheat sheets)

  • Introduces a “steady-state diagram”: a marked board and a priority list of 8 rules that tell red what to do in every response sequence from a given position.08:13

  • Walks through an example:

    • Rule 1: if red can immediately make four in a row, do it.

    • Rule 2: otherwise, if yellow is about to win, block.

    • Next rules: play on special symbols (exclamation marks, plus signs, @ signs) in a fixed priority order; following this always leads to a red win regardless of yellow’s replies.09:08+1

  • Interprets these diagrams as compression: instead of memorizing a large explicit subtree, you memorize a small “program” that implicitly encodes all winning replies in that region.09:40

• Combining opening graph + steady states

  • Explains that steady-state diagrams only work once the game is already constrained (mid–endgame), not from the initial empty board.09:53

  • So the overall solution is: build a weak opening tree, and whenever you reach a position that admits a steady-state diagram, cut off the tree there and attach the diagram as a compressed leaf.10:01

  • Shows a compressed subgraph from a single leaf and contrasts it with how huge the explicit subtree would have been without compression.10:47

• Symmetries and final graph size

  • Observes that the opening graph is horizontally symmetric: yellow playing left vs right leads to mirror responses by red.11:01

  • Discusses a special asymmetric branch (the “61” opening with a central column of 6 and a neighboring column of 1) where red must choose a side, breaking symmetry.11:22

  • Fuses mirror-equivalent nodes to halve the graph further, yielding a solution graph with only 4,550 nodes, over 100× smaller than Allis’s original opening book.11:42+1

• Interpreting the opening map: difficulty of lines

  • Interprets long branches as openings where yellow manages to keep things complex for a long time before a steady-state endgame kicks in.12:05

  • Uses this to define how “challenging” a yellow reply is: the deeper and larger the downstream subgraph, the harder it is for red.12:18

  • Identifies the hardest first move for yellow (against optimal red): playing one column off center, which leaves red with 2,727 downstream nodes to navigate.12:46

  • Shows a particularly large depth-8 position and notes that it corresponds to a well-known, challenging practical opening.13:02

  • Explains that central-column openings come next in difficulty, with many nodes devoted to the “candlesticks” opening (stacked towers) that is largely forced.13:24+1

• Resource trade-offs and compression philosophy

  • Summarizes four solution styles: pure brute-force, pure memorization, hybrid opening-book + endgame search, and pattern-based compression with steady states.13:33

  • Frames them as trade-offs between compute, memory, and offline pattern-finding effort.13:54

• Emergent complexity beyond rules

  • Shifts from Connect 4 to the philosophical point: simple rules can give rise to complexity that cannot be compressed into a short, intuitive explanation.14:10

  • Notes that knowing the rules of Connect 4 doesn’t let you “see” the candlesticks opening, just as knowing particle physics doesn’t directly tell you about clouds.15:00+1

  • Uses cloud taxonomy as an analogy: there is no fundamental law forbidding some specific cloud species, yet meteorology has its own higher-level descriptive language.15:25+1

  • Concludes that Connect 4 is an example of emergent “equivalent magic” that arises from simple iterated rules and can nevertheless be fully mapped in a finite structure (the graph).16:16+1

• Practical tools: flashcards and interactive site

  • Mentions an Anki deck built from the solution and a website where you can play against the weak solution and explore the tree interactively.17:03+1

What are the solutions for the game?

• Under perfect play on 7×6, red (player 1) wins by starting in the center column; side openings for red are losing, and some near-center openings draw or are weaker, so center is the unique truly winning first move in the gods-eye solution.01:14+1

• Yellow’s best practical “solutions” are particular challenging replies—especially playing one column off center—that maximize the remaining graph size and delay simplification while still ultimately losing to perfect red play.12:46

• The video’s final “solution” is not a single line but a compressed weak solution graph + catalog of steady-state diagrams that collectively encode all perfect replies for red against any yellow moves.10:28+1

How are these solutions created?

• The author first uses or references strong-solver tools like Tromp’s fhourstones and modern search results to enumerate vast numbers of positions and classify them as win/draw/loss under perfect play.01:37

• From this, they construct a full strong solution tree, then prune it:

  • Remove any node reachable only through red blunders (losing first moves, non-optimal continuations).05:54+1

  • When multiple red moves are winning in a position, keep just one representative, collapsing equivalent branches into a single weak solution node.06:32+1

• Next, they systematically search for positions where a steady-state diagram can be defined: a simple rule-based program that guarantees a win for red regardless of yellow’s replies.09:40+1

• Whenever such a steady state exists, the explicit subtree is replaced by that compact program; these compressed leaves are the building blocks used to shrink the opening graph.10:13+1

• Finally, they exploit board symmetries, especially left-right reflection, and merge symmetric nodes to further reduce the node count to 4,550, giving the final condensed map of all perfect openings.11:31+1

How are the solutions visualized?

• The opening solution is visualized as a directed graph where:

  • Each node is a game state (up to symmetry).

  • Edges are moves by red or yellow, branching out from the initial empty root.12:05+1

  • Long “spines” show forced or low-branching lines; dense blobs indicate positions with many viable continuations.00:21+1

• A weak solution tree visualization is used early on to illustrate pruning: full trees vs pruned trees vs very compact “pillow-shaped” trees, each reflecting different policies for choosing among winning moves.07:22+1

• Steady-state diagrams are visualized directly on board grids, where symbols (exclamation marks, pluses, @ signs, etc.) on cells correspond to priority rules in the 8-rule list; following the highest-priority available symbol yields a forced win.08:34+1

• The final master visualization is a symmetric, node-reduced graph of 4,550 nodes, interpreted as a topographic “map” of Connect 4 openings whose geometry encodes difficulty and branching behavior.11:42+1

Make a table of openings for connect four. Then, explain the theory of how complexity arise out of simple rules.

Here’s a compact table of the main opening ideas from the video, then a short explanation of emergent complexity.

Connect Four openings (from the video)

These are conceptual openings, not full move-orders; they’re characterized by where red and yellow first place their discs and how complex the resulting branch of the solution graph is.youtube

The video’s solution graph can be read as a map of these openings and their continuations: long branches correspond to challenging yellow replies (like “one off center” or 61–candlesticks structures), while short branches are easy replies that quickly reduce to a steady-state endgame program.12:46+1

How complexity arises from simple rules

The video uses Connect 4 as a miniature case study of emergent complexity: extremely simple rules (7×6 grid, alternate drops, first to four in a row wins) give rise to a solution that, in raw form, needs around 90 GB to encode as a strong lookup table. This mismatch—tiny rule description vs huge solution—illustrates that the full strategic landscape cannot be “compressed” back down to a short verbal explanation without doing massive computation, memorization, or pattern-finding.14:47+2

The structure of the game tree shows this clearly: from the empty board, branching explodes exponentially with depth, producing millions of distinct positions by move 10 despite the rule set being describable in a sentence. Even after you prune blunders and merge symmetric or equivalent winning lines into a weak solution graph, you still need thousands of nodes plus many steady-state diagrams (compact “programs”) to fully capture perfect play.11:42+3

This mirrors how complexity appears in physics: knowing local particle-interaction laws does not make cloud types, weather fronts, or specific storm patterns obvious, even though in principle they all emerge from those laws. Instead, higher-level systems (Connect 4 openings, cloud taxonomies) require their own descriptive languages and concepts that are not reducible to a few simple first principles without losing essential structure. The game becomes a concrete example of emergent structure: repeated application of simple rules generates a rich landscape of strategies and patterns that feel like “equivalent magic,” more intricate than any short rule list can directly convey.16:09+5

Would you like a second table that categorizes openings by “branch length” and whether they quickly hit a steady-state diagram vs staying in a complex midgame?