NumberphileFollowAlongs_StonesOnAnInfiniteChessboard.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/GregSym/Numberphile_Follow_Alongs/blob/spoon/NumberphileFollowAlongs_StonesOnAnInfiniteChessboard.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HC0Ao0b2_2Yj"
      },
      "source": [
        "# Stones on an Infinite Chessboard\n",
        "https://www.youtube.com/watch?v=m4Uth-EaTZ8\n",
        "\n",
        "A game in which a set of starting stones of value one are placed on a theoretically infinite grid in order to generate the largest possible sequence of natural numbers by evaluating the sum of a cell in the aforementioned grid's cells.\n",
        "\n",
        "I suppose part of the challenge here is visualising that so it's not as confusing as I made it sound. The YT video is much easier to follow."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FsM6TG5MjsU8"
      },
      "outputs": [],
      "source": [
        "from __future__ import annotations\n",
        "import collections\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1ngLwQhBZiC8"
      },
      "source": [
        "## Principle setup for running the game"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "34f2MDN6j5YY"
      },
      "outputs": [],
      "source": [
        "board: collections.defaultdict[tuple[int, int], int] = collections.defaultdict(lambda: 0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "K8Pw_eNjkOeC"
      },
      "outputs": [],
      "source": [
        "def setup_init_state(board: collections.defaultdict[int], init_stones=2):\n",
        "  if init_stones==2:\n",
        "    board[(0, 0)] = 1\n",
        "    board[(2, 2)] = 1\n",
        "\n",
        "adjacency = ((-1, -1), (0, -1), (1, -1), (-1, 0), (-1, 1), (1, 0), (0, 1), (1, 1))\n",
        "assert len(set(adjacency)) == 8  # check for 8 unique elements because i screw these up a lot\n",
        "\n",
        "def play_game(board: collections.defaultdict[tuple[int, int], int]):\n",
        "  max_x = max(k[0] for k in board)\n",
        "  max_y = max(k[1] for k in board)\n",
        "  for x in range(max_x+1):\n",
        "    for y in range(max_y+1):\n",
        "      adj_sum = sum(board[(x+dx, y+dy)] for (dx,dy) in adjacency)\n",
        "      if adj_sum not in board.values() and adj_sum == max(board.values()) + 1 and board[(x, y)] == 0:\n",
        "        board[(x, y)] = adj_sum\n",
        "\n",
        "def board_to_data(board: collections.defaultdict[tuple[int, int], int]) -> list[list[int]]:\n",
        "  if any((x<0 or y<0) for x, y in board):\n",
        "    diagonal_shift = collections.defaultdict(lambda: 0)\n",
        "    diagonal_shift.update({(x-min(x for x,y in board), y-min(y for x,y in board)): value for (x,y), value in board.items()})\n",
        "    board = diagonal_shift\n",
        "  max_x = max(x for (x,y) in board)\n",
        "  max_y = max(y for (x,y) in board)\n",
        "  data = np.zeros((max_x+1+1, max_y+1+1))\n",
        "  for (x, y), value in board.items():\n",
        "    data[y, x] = value\n",
        "  return data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nsT0x_dZmAj3",
        "outputId": "11038908-fb9e-47f6-c2bd-1f86146cf34c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0. 0. 0. 0. 0. 0.]\n",
            " [0. 1. 0. 0. 0. 0.]\n",
            " [0. 0. 2. 0. 0. 0.]\n",
            " [0. 0. 3. 1. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0.]]\n",
            "[[0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 1. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 2. 0. 0. 0. 0.]\n",
            " [0. 0. 3. 1. 0. 0. 0.]\n",
            " [0. 0. 4. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0.]]\n"
          ]
        }
      ],
      "source": [
        "setup_init_state(board=board)\n",
        "play_game(board=board)\n",
        "print(board_to_data(board=board))\n",
        "play_game(board=board)\n",
        "print(board_to_data(board=board))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z-HUmjmraVYS"
      },
      "source": [
        "## Packaging some of this functionality"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ylhEw_OEp7IA"
      },
      "outputs": [],
      "source": [
        "from typing import Counter\n",
        "\n",
        "class NumbersAndStones:\n",
        "  \"\"\" Useful namespace for containing the game and its board \"\"\"\n",
        "  def __init__(self, initial_state: int = 2):\n",
        "    self.initial_state = initial_state\n",
        "    self.paths = [set()]\n",
        "    self.blacklist: Counter[Stone] = collections.Counter()\n",
        "    self.recurrances: Counter[str] = collections.Counter()\n",
        "    self.setup()\n",
        "\n",
        "  def setup(self):\n",
        "    self.board: collections.defaultdict[tuple[int, int], int] = collections.defaultdict(lambda: 0)\n",
        "    self.last_state: collections.defaultdict[tuple[int, int], int] = collections.defaultdict(lambda: 0)\n",
        "    setup_init_state(board=self.board, init_stones=self.initial_state)\n",
        "    self.last_state.update(self.board)\n",
        "    self.sequence: set[int] = set()\n",
        "  \n",
        "  def play_game(self):\n",
        "    self.last_state = collections.defaultdict(lambda: 0)\n",
        "    self.last_state.update(self.board)\n",
        "    valid_x = [x for (x,y) in self.board if self.board[x,y] > 0]\n",
        "    valid_y = [y for (x,y) in self.board if self.board[x,y] > 0]\n",
        "    min_x = min(valid_x)\n",
        "    min_y = min(valid_y)\n",
        "    max_x = max(valid_x)\n",
        "    max_y = max(valid_y)\n",
        "    for x in range(min_x-1, max_x+1):\n",
        "      for y in range(min_y-1, max_y+1):\n",
        "        adj_sum = sum(self.board[(x+dx, y+dy)] for (dx,dy) in adjacency)\n",
        "        if (\n",
        "            adj_sum not in self.board.values()\n",
        "            and adj_sum == max(self.board.values()) + 1 \n",
        "            and self.board[(x, y)] == 0\n",
        "            and ((x,y), adj_sum) not in self.blacklist\n",
        "            ):\n",
        "          print(adj_sum)\n",
        "          self.board[(x, y)] = adj_sum\n",
        "          continue\n",
        "  \n",
        "  def evaluate_growth(self) -> bool:\n",
        "    \"\"\" \n",
        "    return whether or not growth stagnated (mathematically this <i>must</i> happen)\n",
        "    irrespective of init state\n",
        "    True: growth\n",
        "    False: stagnated\n",
        "    \"\"\"\n",
        "    return not self.sequence == set({*self.last_state.values()})\n",
        "  \n",
        "  def play_sequence(self):\n",
        "    self.sequence = set()\n",
        "    self.play_game()\n",
        "    while self.evaluate_growth():\n",
        "      self.play_game()\n",
        "      self.sequence.update({*self.board.values()})\n",
        "    if max(self.board.values()) > 3:\n",
        "      failed_placement, = [(indeces, v) for indeces, v in self.board.items() if v==max(self.board.values())]\n",
        "    else:\n",
        "      failed_placement = Stone((0,0), 0)\n",
        "    self.blacklist[Stone(*failed_placement)] += 1\n",
        "    for i in range(self.blacklist[Stone(*failed_placement)]):\n",
        "      new_board = {k: v if v < max(*self.board.values()) or v==1 else 0 for k,v in self.board.items()}\n",
        "      # more_badlist = [Stone(indeces, v) for indeces, v in self.board.items() if v not in new_board.values() and v>3]\n",
        "      # self.blacklist.update({*more_badlist})\n",
        "      self.board.update(new_board)\n",
        "    print(self.blacklist)\n",
        "    if max(self.sequence) < 9:\n",
        "      self.recurrances['re'] += 1\n",
        "      # print(self.recurrances)\n",
        "      self.play_sequence()\n",
        "    self.paths[0].update({i for i,v in self.board.items() if v>1})\n",
        "  \n",
        "  @property\n",
        "  def ndarray(self):\n",
        "    return board_to_data(board=self.board)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lmqgLL6Me4aH"
      },
      "source": [
        "### Abstracting the 'Stone'\n",
        "We're going to want to keep track of some of these, and an easily identifiable object is probably called for\n",
        "\n",
        "(While making Stone I figured I'd just make a tree too, because those are always so fun!)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RRKP4OzXFrqp"
      },
      "outputs": [],
      "source": [
        "from typing import Callable\n",
        "import functools\n",
        "\n",
        "@functools.lru_cache(maxsize=1024)\n",
        "def neighbour_gen(x,y) -> list[tuple[int, int]]:\n",
        "  _neighbour_gen: Callable[[int, int], list[tuple[int, int]]] = lambda x, y: [(x+dx, y+dy) for (dx,dy) in adjacency]\n",
        "  return _neighbour_gen(x,y)\n",
        "\n",
        "@functools.lru_cache(maxsize=1024)\n",
        "def cached_sum(*_arraylike) -> int:\n",
        "  return sum(*_arraylike)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nBF2U__0Wu1M"
      },
      "outputs": [],
      "source": [
        "from typing import NamedTuple, Generator, Union\n",
        "\n",
        "class Stone(NamedTuple):\n",
        "  index: tuple[int, int]\n",
        "  value: int\n",
        "\n",
        "  def __eq__(self, other) -> bool:\n",
        "    \"\"\" ensure nested equality of the tuple \"\"\"\n",
        "    if isinstance(other, Stone):\n",
        "      return (other.index == self.index) and (other.value == self.value)\n",
        "    if isinstance(other, tuple):\n",
        "      return (other[0] == self.index) and (other[1] == self.value)\n",
        "    return False\n",
        "\n",
        "class Node(NamedTuple):\n",
        "  \"\"\" repr for a point in the PossibilityTree \"\"\"\n",
        "  stone: Stone\n",
        "  parent: Union[Node, None]\n",
        "  children: list[Node]\n",
        "\n",
        "class PossibilityTree(NamedTuple):\n",
        "  root: Node\n",
        "  init_board: collections.defaultdict[tuple[int, int], int]\n",
        "\n",
        "  def _get_parent_chain(self, node: Node) -> Generator[Node, None, None]:\n",
        "    yield node\n",
        "    if node == self.root:\n",
        "      return\n",
        "    for upstream in self._get_parent_chain(node=node.parent):  # this will fail after 999\n",
        "      yield upstream\n",
        "\n",
        "  @property\n",
        "  def nodes(self) -> Generator[Node, None, None]:\n",
        "    def ret_children(node: Node) -> Generator[Node, None, None]:\n",
        "      yield node\n",
        "      for node in node.children:\n",
        "        for nested in ret_children(node):\n",
        "          yield nested\n",
        "    for nested in ret_children(self.root):\n",
        "      yield nested\n",
        "\n",
        "  def add_node(self, node: Node):\n",
        "    for n in self.nodes:\n",
        "      if n.stone == node.parent:\n",
        "        n.children.append(node)\n",
        "  \n",
        "  @property\n",
        "  def layers(self) -> collections.defaultdict[int, list[Node]]:\n",
        "    \"\"\" () -> dict[number of layer, all Stones in a layer of the tree] \"\"\"\n",
        "    _layers: collections.defaultdict[int, list[Node]] = collections.defaultdict(lambda: list())\n",
        "    for node in self.nodes:\n",
        "      _layers[node.stone.value].append(node)\n",
        "    return _layers\n",
        "  \n",
        "  @property\n",
        "  def max_layer(self) -> set[Node]:\n",
        "    _layers = self.layers  # don't run twice / pre-calc here\n",
        "    return _layers[max(_layers)]\n",
        "  \n",
        "  def board_from_node(self, node: Node, low_memory=False) -> collections.defaultdict[tuple[int, int], int]:\n",
        "    _board = collections.defaultdict(lambda: 0)\n",
        "    _board.update(self.init_board)\n",
        "    _board.update({(x,y): value for ((x,y), value), parent, children in self.sequence_at_node(node=node)})\n",
        "    return _board\n",
        "\n",
        "  @property\n",
        "  def longest_board(self) -> collections.defaultdict[tuple[int, int], int]:\n",
        "    return self.board_from_node(node=self.longest_node)\n",
        "\n",
        "  def new_layer(self):\n",
        "    \"\"\" compute and append a new layer to the highest layer \"\"\"\n",
        "    new_layer_value = max(self.layers) + 1\n",
        "    print(new_layer_value)\n",
        "    for node in self.max_layer:\n",
        "      current_board = self.board_from_node(node)\n",
        "      for (x, y), num in current_board.items():\n",
        "        for nx, ny in neighbour_gen(x,y):\n",
        "          if current_board.get((nx, ny), 0) != 0:\n",
        "            continue\n",
        "          adj_sum = cached_sum(current_board.get((nx+dx, ny+dy), 0) for (dx,dy) in adjacency)\n",
        "          if adj_sum == new_layer_value:\n",
        "            node.children.append(\n",
        "                Node(stone=Stone(index=(nx,ny), value=new_layer_value), parent=node, children=[]))\n",
        "\n",
        "  @property\n",
        "  def longest_node(self) -> Node:\n",
        "    \"\"\" returns an arbitrary node in the maximum number layer \"\"\"\n",
        "    return self.max_layer.pop()\n",
        "  \n",
        "  def sequence_at_node(self, node: Node) -> Generator[Node, None, None]:\n",
        "    for _node in self._get_parent_chain(node):\n",
        "      yield _node\n",
        "  \n",
        "  @property\n",
        "  def longest_sequence(self) -> Generator[Node, None, None]:\n",
        "    for node in self.sequence_at_node(self.longest_node):\n",
        "      yield node\n",
        "\n",
        "  @property\n",
        "  def branch_points(self) -> Generator[Node, None, None]:\n",
        "    for node in self.nodes:\n",
        "      if len(node.children) > 1:\n",
        "        yield node"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qfBYwOT-Qqbv"
      },
      "source": [
        "## Abstract class for visualisation integration"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZEzJ7CKESFKU"
      },
      "outputs": [],
      "source": [
        "import sys\n",
        "if float(f\"{sys.version_info[0]}.{sys.version_info[1]}\") < 3.8:\n",
        "  from typing_extensions import Protocol  # < 3.8 Protocol lives in a different package\n",
        "else:\n",
        "  from typing import Protocol\n",
        "\n",
        "class _GrowableNumberPattern(Protocol):\n",
        "  @property\n",
        "  def board(self) -> dict[tuple[int,int], int]:...\n",
        "  @property\n",
        "  def sequence(self) -> set[int]:...\n",
        "  @property\n",
        "  def ndarray(self):..."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yIhaP8QNQy30"
      },
      "outputs": [],
      "source": [
        "from abc import ABC, abstractmethod\n",
        "\n",
        "class NumbersAndStonesABC(ABC):\n",
        "  \"\"\" Parent ABC that cheats by containing some useful visualisation stuff that\n",
        "      could clutter up the solver\n",
        "  \"\"\"\n",
        "  @abstractmethod\n",
        "  def play_sequence(self):\n",
        "    \"\"\" Play out all possible sequences for an initial state defined before calling \"\"\"\n",
        "  \n",
        "  @property\n",
        "  def ndarray(self):\n",
        "    return board_to_data(board=self.board)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "60iFunjw_bIz"
      },
      "outputs": [],
      "source": [
        "class NumbersAndStones(NumbersAndStonesABC):\n",
        "  \"\"\" Useful namespace for containing the game and its board \"\"\"\n",
        "  def __init__(self, initial_state: int = 2):\n",
        "    self.initial_state = initial_state\n",
        "    self.board: collections.defaultdict[tuple[int, int], int] = collections.defaultdict(lambda: 0)\n",
        "    setup_init_state(board=self.board, init_stones=self.initial_state)\n",
        "    root = Stone(*[stone for stone in self.board.items()][0])\n",
        "    self.sequence = []\n",
        "    self.tree: PossibilityTree = PossibilityTree(\n",
        "        Node(stone=root, parent=None, children=[]), self.board)\n",
        "  \n",
        "  def play_sequence(self):\n",
        "    while True:\n",
        "      # store current layer\n",
        "      layer_value = self.tree.longest_node.stone.value\n",
        "      # get a new layer\n",
        "      self.tree.new_layer()\n",
        "      # find new layer\n",
        "      new_value = self.tree.longest_node.stone.value\n",
        "      # test for growth\n",
        "      if new_value == layer_value:\n",
        "        self.board = self.tree.longest_board\n",
        "        break\n",
        "    self.sequence = [*self.board.values()]\n",
        "    print(self.board)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "l8MJWzyJU_KE",
        "outputId": "c62b2548-c45b-4cac-d451-54292f8e78c8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Cold run...\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n",
            "11\n",
            "12\n",
            "13\n",
            "14\n",
            "15\n",
            "16\n",
            "17\n",
            "defaultdict(<function PossibilityTree.board_from_node.<locals>.<lambda> at 0x7fe10e1a9440>, {(0, 0): 1, (2, 2): 1, (-1, -1): 16, (0, -1): 15, (1, -1): 14, (2, 0): 13, (1, 4): 12, (3, 1): 11, (3, 2): 10, (3, 4): 9, (1, 3): 8, (-1, 1): 7, (0, 1): 6, (3, 3): 5, (2, 3): 4, (1, 2): 3, (1, 1): 2})\n",
            "[[16. 15. 14.  0.  0.  0.  0.]\n",
            " [ 0.  1.  0. 13.  0.  0.  0.]\n",
            " [ 7.  6.  2.  0. 11.  0.  0.]\n",
            " [ 0.  0.  3.  1. 10.  0.  0.]\n",
            " [ 0.  0.  8.  4.  5.  0.  0.]\n",
            " [ 0.  0. 12.  0.  9.  0.  0.]]\n",
            "[1, 1, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2]\n",
            "[[16. 15. 14.  0.  0.  0.  0.]\n",
            " [ 0.  1.  0. 13.  0.  0.  0.]\n",
            " [ 7.  6.  2.  0. 11.  0.  0.]\n",
            " [ 0.  0.  3.  1. 10.  0.  0.]\n",
            " [ 0.  0.  8.  4.  5.  0.  0.]\n",
            " [ 0.  0. 12.  0.  9.  0.  0.]]\n",
            "[1, 1, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2]\n"
          ]
        }
      ],
      "source": [
        "from typing import Any\n",
        "\n",
        "class ComputedGame(NamedTuple):\n",
        "  \"\"\"\n",
        "  Contains only the data of a game,\n",
        "  fulfills interface/Protocol but doesn't inherit from ABC version.\n",
        "  Primarily for caching the game, may have mocking applications\n",
        "  \"\"\"\n",
        "  initial_state: int\n",
        "  board: collections.defaultdict[tuple[int,int], int]\n",
        "  tree: PossibilityTree\n",
        "  sequence: list[int]\n",
        "  ndarray: Any  # npt.NDArray[np.int64] (note: numpy.typing=npt, numpy=np)\n",
        "\n",
        "  def play_sequence(self):...\n",
        "\n",
        "@functools.lru_cache(maxsize=None)\n",
        "def cache_tree_computation() -> ComputedGame:\n",
        "  print(\"Cold run...\")\n",
        "  game = NumbersAndStones()\n",
        "  game.play_sequence()\n",
        "  print(game.ndarray)\n",
        "  print(game.sequence)\n",
        "  return ComputedGame(initial_state=game.initial_state, \n",
        "                      board=game.board, \n",
        "                      tree=game.tree,\n",
        "                      sequence=game.sequence, \n",
        "                      ndarray=game.ndarray)\n",
        "\n",
        "game = cache_tree_computation()\n",
        "print(game.ndarray)\n",
        "print(game.sequence)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4aZSoDfuEZDK"
      },
      "source": [
        "## Should probably test some fundamentals"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "BVt4264KEd03"
      },
      "outputs": [],
      "source": [
        "def test_natural_numbers(pattern: _GrowableNumberPattern):\n",
        "  for el, next_el in zip(sorted(set(pattern.sequence)), list(sorted(set(pattern.sequence)))[1:]):\n",
        "    assert el + 1 == next_el, f\"sequence break @ {el} - {next_el}\"\n",
        "\n",
        "def test_largest_eq_sum(pattern: _GrowableNumberPattern):\n",
        "  ((x,y), max_v), = [((x,y),max_v) for (x,y),max_v in pattern.board.items() if max_v==max(pattern.board.values())]\n",
        "  assert sum(pattern.board[(x+dx, y+dy)] for (dx,dy) in adjacency) == max_v, f\"{sum(pattern.board[(x+dx, y+dy)] for (dx,dy) in adjacency)} not equal to {max_v},\\n board:\\n {pattern.ndarray}\"\n",
        "  if max_v > 2:\n",
        "    pattern.board.pop((x,y))\n",
        "    test_largest_eq_sum(pattern=pattern)\n",
        "  return\n",
        "      \n",
        "game = cache_tree_computation()\n",
        "game.play_sequence()\n",
        "test_natural_numbers(game)\n",
        "test_largest_eq_sum(game)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FI5MZovBIs9I"
      },
      "source": [
        "## But can it look more interesting than an NDArray?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "TzNekZSrVaoN",
        "outputId": "077030dd-646e-4e90-83b4-85d48477bd00"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import sys\n",
        "\n",
        "class _VisualiserInterfaceCheckerboardCounting(Protocol):\n",
        "  \"\"\" Interface for visualisation in this notebook \"\"\"\n",
        "  def __call__(self, pattern: _GrowableNumberPattern, verbose: bool) -> None:\n",
        "      ...\n",
        "\n",
        "def visualise_checkerboard_counting(pattern: _GrowableNumberPattern, verbose: bool = False):\n",
        "  \"\"\" (pattern) -> visualisation of checkerboard counting game \"\"\"\n",
        "  # src: https://stackoverflow.com/questions/36668160/graphing-a-colored-grid-in-python\n",
        "  # thanccs == asker: fosho, answerer: Suever\n",
        "  # Just some example data (random)\n",
        "  data = pattern.ndarray  # change this line to control colour map\n",
        "\n",
        "  rows,cols = data.shape\n",
        "  plt.imshow(data[::-1,::], interpolation='nearest', \n",
        "                  extent=[0, 0+cols, 0, 0+rows],  # offset should be zero\n",
        "                  cmap='Blues')  # controls colour scheme\n",
        "  # write stone value to the heat map\n",
        "  for (y,x), stone in np.ndenumerate(data):\n",
        "    plt.text(x+.5, y+.5, str(stone), ha='center', va='center',\n",
        "            bbox=dict(boxstyle='round', facecolor='white', edgecolor='0.3'))\n",
        "  # plt.axes()\n",
        "  plt.axis('scaled')\n",
        "  plt.show()\n",
        "\n",
        "# run it\n",
        "game = cache_tree_computation()\n",
        "game.play_sequence()\n",
        "visualise_checkerboard_counting(pattern=game)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "qJ_mPr-kZNAr"
      },
      "outputs": [],
      "source": [
        ""
      ]
    }
  ],
  "metadata": {
    "colab": {
      "name": "NumberphileFollowAlongs_StonesOnAnInfiniteChessboard.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyMJzjvD0jET3RrikGSdhL16",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}