A Tic-tac-toe sandbox to experiment with Alex Wissner-Gross's causal-entropic intelligence equation.

In this application, the causal-entropy player treats each legal Tic-tac-toe move as a step into a future game tree. As defined by $\mathbf{F} = T \nabla S_\tau$, it prefers moves whose successor states leave many legal future histories available, instead of directly optimizing a win/loss utility score. For this reason we observe that the causal-entropy favours placing marks on the edges of the board to minimise the probability of loosing, in favour of dominating the center to maximise the probability of winning.

...Basicaly, the agent that avoids loosing, lives longer, than the agent that tries to win.
...There may be some philisophical value in that observation somewhere.

• ✅ Requirements
• ⚙️ Setup
• ▶️ Running
• 🧩 Configuration
• 🧮 Mathematical Overview
• 🎮 Tic-tac-toe - Mathematical Definition
• 🗂️ Project Layout
• ⚠️ Experiment Limitations
• 📜 License

• Python 3.12 or newer
• A UTF-8 terminal for Unicode boards; other encodings receive an ASCII fallback

Create a virtual environment, then install the dependencies.

python -m venv .venv
.\.venv\Scripts\python.exe -m pip install -r requirements.txt

python3 -m venv .venv
./.venv/bin/python -m pip install -r requirements.txt

py -3.12 -m venv .venv
./.venv/Scripts/python.exe -m pip install -r requirements.txt

Use requirements-dev.txt only when you want the optional local test dependencies.

From the project directory, display the available command-line options:

• Windows

  .\run.bat --help

• Linux

  ./run.sh --help

Run the example causal-entropy match:

• Windows

  .\run.bat config\example.yaml

• Linux

  ./run.sh config/example.yaml

Run a causal-entropy versus minimax experiment with candidate-score diagnostics:

• Windows

  .\run.bat config\experiments\causal-entropy-x-minimax-o.yaml

• Linux

  ./run.sh config/experiments/causal-entropy-x-minimax-o.yaml

The selected YAML profiles determine whether a match is human-human, human-computer, or computer-computer. Human turns accept coordinates from a1 through c3; malformed and occupied coordinates are explained and re-prompted.

Each YAML file defines an x.y version number, optional application settings, reusable player profiles, one selected match, and presentation settings. An integer application.random_seed makes random strategy choices and random tie-breaks repeatable; omit it or set it to null for fresh random initialization on each run.

Player 1 is always X and moves first. Computer profiles select one of these strategies:

The included files under config/ show the supported profile, match, and presentation settings.

Wissner-Gross's causal-entropic force,

says that a system is driven toward states with greater future path entropy. Tic-tac-toe is discrete, so the application replaces the smooth gradient with an action-wise finite difference over legal moves.

Let $s$ be the current Tic-tac-toe state, $A(s)$ the legal actions, and $T_g(s,a)$ the successor state reached by playing action $a$. The subscript in $T_g$ distinguishes the game transition function from the temperature-like scalar $T$ in the intelligence equation. The formal Tic-tac-toe definition below uses $T$ for the same game transition function, matching the notation in the reference model.

For a configured horizon $\tau$, the causal-entropy strategy counts uniformly weighted future histories:

The path entropy used by the application is the natural logarithm of that count:

Each candidate move is scored by the discrete analogue of $T \nabla S_\tau$:

where $\theta$ is the configured temperature parameter. Since $S_\tau(s)$ is constant for all candidate moves from the same state, choosing the largest $C(s,a)$ is equivalent to choosing the successor with the largest future path entropy.

The strategy intentionally does not add win/loss utility, tactical rules, or an opponent model. Wins, losses, and draws affect the score only by ending the future-history count. This makes the causal-entropy player a direct test of future optionality inside the Tic-tac-toe game defined below.

Tic-tac-toe is modeled as a finite, deterministic, two-player, turn-based, zero-sum game of perfect information:

where $S$ is the legal reachable state space, $s_0$ is the initial state, $A(s)$ is the legal action function, $P(s)$ is the player-to-move function, $T(s,a)$ is the transition function, $O(s)$ is the outcome function, and $U_i(s)$ is the utility function for player $i$.

Let the row and column sets be:

The set of board cells is:

The marks are:

The empty cell symbol is $\emptyset$, and the set of possible cell values is:

The set of players is:

Each player is identified with their mark. Player $X$ moves first, and player $O$ moves second.

A board is a function:

The raw board space is:

Since $|D| = 9$ and $|\Sigma| = 3$, there are $|B| = 3^9 = 19683$ raw board configurations. The legal state space $S$ is a subset of $B$ because some raw boards violate turn order or could not arise after normal play.

For a board $b$, define the mark counts:

Because $X$ moves first and players alternate turns, every reachable non-corrupt board satisfies:

or:

Equivalently:

The set of winning lines is:

For a player $m \in M$, the win predicate is:

A board is full if no cell is empty:

Equivalently:

A board is terminal if either player has won or the board is full:

The initial state $s_0$ is the empty board:

The legal state space is the smallest set $S \subseteq B$ such that:

1. $s_0 \in S$.
2. If $s \in S$, $s$ is non-terminal, and $a \in A(s)$, then $T(s,a) \in S$.
3. If $Z(s)$, then $A(s) = \varnothing$.

This recursive definition excludes boards that satisfy simple count constraints but could not arise during actual game play.

For non-terminal states, the player-to-move function is:

The function $P(s)$ is undefined for terminal states because no player moves after the game ends.

An action is the selection of an empty board cell:

The legal action set is the set of empty cells:

For terminal states, no actions are legal:

For a state $s \in S$ and legal action $a \in A(s)$, the successor state $s' = T(s,a)$ is:

The transition function is only defined when $a \in A(s)$ and $\neg Z(s)$.

The outcome function is:

with:

The utility functions are:

For player $X$:

For player $O$:

For terminal states, Tic-tac-toe is zero-sum:

A history is a finite legal action sequence:

The induced state $s_h$ is obtained by applying those actions in order from $s_0$, and:

A pure strategy for player $i \in I$ maps every state where that player moves to a legal action:

where:

and:

For player $X$, the minimax value function is:

with:

for terminal states, and:

Similarly, $V_O(s) = -V_X(s)$ because the game is zero-sum. Tic-tac-toe is solved: the value of the initial state is:

so optimal play results in a draw.

• Each example result is one seeded game, not a statistical comparison.
• In matches with random strategies or random tie-breakers, role assignment affects how the shared seeded random stream is consumed.
• Execution times are machine-specific and are not acceptance thresholds.
• The causal-entropy strategy intentionally ignores wins, losses, and opponent quality except through future path counts.
• Tic-tac-toe is a small demonstration domain; these results do not establish a general measure of intelligence.

Released under the MIT License — Copyright © 2022 Rohin Gosling.