{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "(user_guide_custom_ga)="
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# Building a Custom Genetic Algorithm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "\ud83d\udcd6 {ref}`Optimization API Reference <api_optimization>`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "This notebook walks through the process of writing a custom genetic algorithm on top of `sigmaepsilon.math.optimize`, reusing as much of the library's infrastructure as possible. {py:class}`~sigmaepsilon.math.optimize.bga.BinaryGeneticAlgorithm`, {py:class}`~sigmaepsilon.math.optimize.iga.IntegerGeneticAlgorithm` and {py:class}`~sigmaepsilon.math.optimize.rga.RealValuedGeneticAlgorithm` (all covered in the {doc}`Optimization <index>` guide) are themselves nothing more than examples of exactly this process \u2014 small subclasses of {py:class}`~sigmaepsilon.math.optimize.ga.GeneticAlgorithm` that plug in a specific genotype representation. By the end of this notebook you'll have written a fourth one from scratch, and understand precisely which parts of the framework you get for free and which parts are genuinely yours to design."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Why do we need a *custom* class here?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "The three built-in classes all assume the decision variables are **independent**: each one lives in its own box (`ranges[d]`), and crossover/mutation can touch one variable without affecting the validity of the others. That covers a huge range of problems, but not all of them.\n\nAs a running example, we'll solve a small [Traveling Salesman Problem](https://en.wikipedia.org/wiki/Travelling_salesman_problem) (TSP): given a set of cities, find the shortest closed tour that visits every city exactly once. The natural representation for a candidate solution is a **permutation** of city indices \u2014 and permutations are exactly the case the box-independent assumption breaks down: if you mutate or crossover each position independently (the way {py:class}`~sigmaepsilon.math.optimize.bga.BinaryGeneticAlgorithm`/{py:class}`~sigmaepsilon.math.optimize.iga.IntegerGeneticAlgorithm`/{py:class}`~sigmaepsilon.math.optimize.rga.RealValuedGeneticAlgorithm` do), you'll almost certainly end up with a city missing and another one repeated \u2014 not a valid tour at all. We need crossover and mutation operators that are aware of the permutation constraint, which means writing our own {py:class}`~sigmaepsilon.math.optimize.ga.GeneticAlgorithm` subclass."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## The extension points, recapped"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "{py:class}`~sigmaepsilon.math.optimize.ga.GeneticAlgorithm` is built as a template-method: the evolution loop itself (`evolver`/`evolve`/`solve`, elitism, champion tracking, stopping) is fixed, and a subclass plugs in the representation-specific pieces:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "| method | role | default in `GeneticAlgorithm` |\n|---|---|---|\n| `populate` | produce a pool of genotypes | raises `NotImplementedError` \u2014 must override |\n| `crossover` | combine two parents into two offspring | raises `NotImplementedError` \u2014 must override |\n| `mutate` | perturb one genotype | raises `NotImplementedError` \u2014 must override |\n| `encode` / `decode` | genotype &#8596; phenotype | identity \u2014 override only if they differ |\n| `select` | pick the survivors of a generation | pluggable, backed by `selection_strategy` \u2014 usually left alone |\n| `stopping_criteria` | decide when to stop early | \"champion age exceeds `maxage`\" \u2014 override for a different rule |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "For our permutation GA, `populate`/`crossover`/`mutate` are genuinely new (that's the whole point), while `encode`/`decode`/`select`/`stopping_criteria` \u2014 plus a good deal of bookkeeping in `__init__` (population-size validation, `elitism`, the per-instance `rng`, `selection_strategy`, `vectorized`/`n_jobs` evaluation) \u2014 can be reused as-is."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2026-07-03T19:39:14.328852Z",
     "iopub.status.busy": "2026-07-03T19:39:14.328406Z",
     "iopub.status.idle": "2026-07-03T19:39:15.564653Z",
     "shell.execute_reply": "2026-07-03T19:39:15.564358Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sigmaepsilon.math.optimize.ga import GeneticAlgorithm\n",
    "from sigmaepsilon.math.optimize import RankSelection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Step 0 \u2014 Define the problem\n\nA handful of randomly placed cities, and the objective function: the total length of the closed tour that visits them in the order given by `order` (an array of city indices)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2026-07-03T19:39:15.566419Z",
     "iopub.status.busy": "2026-07-03T19:39:15.566253Z",
     "iopub.status.idle": "2026-07-03T19:39:15.569469Z",
     "shell.execute_reply": "2026-07-03T19:39:15.569183Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "city_rng = np.random.default_rng(42)\n",
    "n_cities = 15\n",
    "coords = city_rng.uniform(0, 100, size=(n_cities, 2))\n",
    "\n",
    "\n",
    "def tour_length(order):\n",
    "    order = np.asarray(order, dtype=int)\n",
    "    points = coords[order]\n",
    "    points_next = np.roll(points, -1, axis=0)\n",
    "    return np.sum(np.linalg.norm(points - points_next, axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2026-07-03T19:39:15.570800Z",
     "iopub.status.busy": "2026-07-03T19:39:15.570690Z",
     "iopub.status.idle": "2026-07-03T19:39:15.656080Z",
     "shell.execute_reply": "2026-07-03T19:39:15.655581Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(4, 4))\n",
    "plt.scatter(coords[:, 0], coords[:, 1])\n",
    "for i, (x, y) in enumerate(coords):\n",
    "    plt.annotate(str(i), (x, y))\n",
    "plt.title(f\"{n_cities} cities to visit\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "We'll minimize `tour_length`, so every GA instance below is constructed with `minimize=True`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Step 1 \u2014 Subclass `GeneticAlgorithm` and adapt `__init__`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "{py:class}`~sigmaepsilon.math.optimize.ga.GeneticAlgorithm`'s constructor takes `(fnc, ranges, *, ...)`, and uses `ranges` for two things: deriving `self.dim` (`self.ranges.shape[0]`, unless `fnc` has a `.dimension` attribute) and \u2014 in the built-in subclasses \u2014 scaling decoded values into a box. Our permutation problem has neither continuous ranges nor independent variables, but we still want `self.dim` to come out as the number of cities, so we accept `n_cities` directly and synthesize a placeholder `ranges` purely to get `self.dim` right; nothing in our GA will actually read the bounds inside it. Everything else \u2014 `nPop`, `elitism`, `seed`, `selection_strategy`, `vectorized`, `n_jobs`, ... \u2014 is simply forwarded to {py:class}`~sigmaepsilon.math.optimize.ga.GeneticAlgorithm`'s `__init__` via `**kwargs`, unchanged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2026-07-03T19:39:15.678460Z",
     "iopub.status.busy": "2026-07-03T19:39:15.678298Z",
     "iopub.status.idle": "2026-07-03T19:39:15.680596Z",
     "shell.execute_reply": "2026-07-03T19:39:15.680328Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class PermutationGeneticAlgorithm(GeneticAlgorithm):\n",
    "    __slots__ = ()\n",
    "\n",
    "    def __init__(self, fnc, n_cities, **kwargs):\n",
    "        placeholder_ranges = [[0, n_cities - 1]] * n_cities\n",
    "        super().__init__(fnc, placeholder_ranges, **kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Before we implement `populate`/`crossover`/`mutate`, let's confirm the base class's contract really is enforced: constructing an instance calls `reset()`, which eagerly calls `populate()` to build the first generation, so instantiating now should fail loudly rather than silently doing nothing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2026-07-03T19:39:15.682162Z",
     "iopub.status.busy": "2026-07-03T19:39:15.682045Z",
     "iopub.status.idle": "2026-07-03T19:39:15.684032Z",
     "shell.execute_reply": "2026-07-03T19:39:15.683741Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fails as expected: PermutationGeneticAlgorithm does not implement 'populate'.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    PermutationGeneticAlgorithm(tour_length, n_cities, nPop=8)\n",
    "except NotImplementedError as e:\n",
    "    print(\"Fails as expected:\", e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Step 2 \u2014 `populate`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "`populate(genotypes=None)` has two responsibilities, following the same pattern as {py:class}`~sigmaepsilon.math.optimize.bga.BinaryGeneticAlgorithm`/{py:class}`~sigmaepsilon.math.optimize.rga.RealValuedGeneticAlgorithm`:\n\n- if `genotypes is None` (the very first generation), create `nPop / 2` random genotypes \u2014 here, random permutations of `range(n_cities)` via `self.rng.permutation`;\n- otherwise, `genotypes` are the `nPop / 2` survivors returned by `select()`, and we need to breed them back up to a full population of `nPop` via `random_parents_generator` (inherited, unchanged) and our own `crossover`.\n\nOne subtlety worth calling out explicitly: {py:class}`~sigmaepsilon.math.optimize.ga.GeneticAlgorithm`'s `select` (which we are about to reuse unmodified) always returns `dtype=float`, since it was written with continuous phenotypes in mind. Our genotypes must stay integer city indices, so `populate` casts back to `int` right at the top."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2026-07-03T19:39:15.685669Z",
     "iopub.status.busy": "2026-07-03T19:39:15.685554Z",
     "iopub.status.idle": "2026-07-03T19:39:15.688049Z",
     "shell.execute_reply": "2026-07-03T19:39:15.687797Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def populate(self, genotypes=None):\n",
    "    nPop = self.nPop\n",
    "\n",
    "    if genotypes is None:\n",
    "        genotypes = np.array(\n",
    "            [self.rng.permutation(self.dim) for _ in range(int(nPop / 2))]\n",
    "        )\n",
    "    else:\n",
    "        genotypes = np.asarray(genotypes, dtype=int)\n",
    "\n",
    "    nParent = genotypes.shape[0]\n",
    "\n",
    "    if nParent < nPop:\n",
    "        offspring = []\n",
    "        parent_pairs = self.random_parents_generator(genotypes)\n",
    "        while (len(offspring) + nParent) < nPop:\n",
    "            parent1, parent2 = next(parent_pairs)\n",
    "            offspring.extend(self.crossover(parent1, parent2))\n",
    "        genotypes = np.vstack([genotypes, offspring])\n",
    "\n",
    "    return genotypes\n",
    "\n",
    "\n",
    "PermutationGeneticAlgorithm.populate = populate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Step 3 \u2014 `crossover`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Naive crossover (e.g. cutting both parents at the same point and swapping halves, like {py:class}`~sigmaepsilon.math.optimize.bga.BinaryGeneticAlgorithm` does) would produce invalid tours: a city could appear twice in the child and another not at all. We need an operator that's aware of the permutation constraint \u2014 the classic choice is **order crossover (OX)**:\n\n1. pick two random cut points and copy the slice between them from parent 1 into the child, unchanged;\n2. fill the remaining positions, in the order they appear in parent 2, skipping any city that's already in the copied slice.\n\nThis guarantees the child is a valid permutation, while still inheriting structure from both parents. We build both children (swapping the parents' roles) and immediately hand each one to `mutate` \u2014 mirroring exactly the shape of {py:class}`~sigmaepsilon.math.optimize.bga.BinaryGeneticAlgorithm`'s `crossover`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2026-07-03T19:39:15.689529Z",
     "iopub.status.busy": "2026-07-03T19:39:15.689417Z",
     "iopub.status.idle": "2026-07-03T19:39:15.692075Z",
     "shell.execute_reply": "2026-07-03T19:39:15.691749Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def crossover(self, parent1, parent2):\n",
    "    n = self.dim\n",
    "\n",
    "    if self.rng.random() > self.p_c:\n",
    "        return parent1.copy(), parent2.copy()\n",
    "\n",
    "    i, j = sorted(self.rng.choice(n, size=2, replace=False))\n",
    "\n",
    "    def order_crossover(donor, filler):\n",
    "        child = -np.ones(n, dtype=int)\n",
    "        child[i:j] = donor[i:j]\n",
    "        remaining = [city for city in filler if city not in child[i:j]]\n",
    "        child[child == -1] = remaining\n",
    "        return child\n",
    "\n",
    "    child1 = order_crossover(parent1, parent2)\n",
    "    child2 = order_crossover(parent2, parent1)\n",
    "    return self.mutate(child1), self.mutate(child2)\n",
    "\n",
    "\n",
    "PermutationGeneticAlgorithm.crossover = crossover"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Step 4 \u2014 `mutate`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Similarly, mutating by flipping bits (as {py:class}`~sigmaepsilon.math.optimize.bga.BinaryGeneticAlgorithm` does) makes no sense for a permutation. The standard choice is **swap mutation**: with probability `p_m`, pick two positions and swap their cities. That's it \u2014 the result is trivially still a valid permutation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2026-07-03T19:39:15.694025Z",
     "iopub.status.busy": "2026-07-03T19:39:15.693910Z",
     "iopub.status.idle": "2026-07-03T19:39:15.695884Z",
     "shell.execute_reply": "2026-07-03T19:39:15.695622Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def mutate(self, child):\n",
    "    if self.rng.random() < self.p_m:\n",
    "        child = child.copy()\n",
    "        i, j = self.rng.choice(self.dim, size=2, replace=False)\n",
    "        child[i], child[j] = child[j], child[i]\n",
    "    return child\n",
    "\n",
    "\n",
    "PermutationGeneticAlgorithm.mutate = mutate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "With `mutate` in place too, we can finally instantiate the class (recall it failed above) and sanity-check `crossover`/`mutate` together, on two small, human-readable permutations, before trusting them inside a full GA run:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2026-07-03T19:39:15.697304Z",
     "iopub.status.busy": "2026-07-03T19:39:15.697193Z",
     "iopub.status.idle": "2026-07-03T19:39:15.702511Z",
     "shell.execute_reply": "2026-07-03T19:39:15.702198Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parent 1: [0 1 2 3 4 5 6 7]\n",
      "parent 2: [3 7 5 1 6 0 2 4]\n",
      "child 1:  [7 1 2 3 4 5 6 0]\n",
      "child 2:  [2 7 5 1 6 0 3 4]\n",
      "both children are valid permutations: True\n"
     ]
    }
   ],
   "source": [
    "toy_ga = PermutationGeneticAlgorithm(lambda order: 0.0, 8, nPop=8, seed=0)\n",
    "toy_parent1 = np.array([0, 1, 2, 3, 4, 5, 6, 7])\n",
    "toy_parent2 = np.array([3, 7, 5, 1, 6, 0, 2, 4])\n",
    "\n",
    "toy_child1, toy_child2 = toy_ga.crossover(toy_parent1, toy_parent2)\n",
    "print(\"parent 1:\", toy_parent1)\n",
    "print(\"parent 2:\", toy_parent2)\n",
    "print(\"child 1: \", toy_child1)\n",
    "print(\"child 2: \", toy_child2)\n",
    "print(\"both children are valid permutations:\", set(toy_child1) == set(toy_child2) == set(range(8)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## What we *didn't* have to write"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "With `populate`/`crossover`/`mutate` in place, the class is fully functional \u2014 everything else is inherited from {py:class}`~sigmaepsilon.math.optimize.ga.GeneticAlgorithm` untouched:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2026-07-03T19:39:15.704038Z",
     "iopub.status.busy": "2026-07-03T19:39:15.703890Z",
     "iopub.status.idle": "2026-07-03T19:39:15.706197Z",
     "shell.execute_reply": "2026-07-03T19:39:15.705826Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "encode/decode/select/divide/stopping_criteria/random_parents_generator: all reused as-is\n"
     ]
    }
   ],
   "source": [
    "assert PermutationGeneticAlgorithm.encode is GeneticAlgorithm.encode\n",
    "assert PermutationGeneticAlgorithm.decode is GeneticAlgorithm.decode\n",
    "assert PermutationGeneticAlgorithm.select is GeneticAlgorithm.select\n",
    "assert PermutationGeneticAlgorithm.divide is GeneticAlgorithm.divide\n",
    "assert PermutationGeneticAlgorithm.stopping_criteria is GeneticAlgorithm.stopping_criteria\n",
    "assert PermutationGeneticAlgorithm.random_parents_generator is GeneticAlgorithm.random_parents_generator\n",
    "print(\"encode/decode/select/divide/stopping_criteria/random_parents_generator: all reused as-is\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "`encode`/`decode` default to the identity mapping, which is exactly right here: our genotype (a permutation of city indices) already *is* the phenotype, the same way it is for {py:class}`~sigmaepsilon.math.optimize.rga.RealValuedGeneticAlgorithm`. `select` already comes with a working, pluggable implementation backed by `selection_strategy` (default {py:class}`~sigmaepsilon.math.optimize.selection.TournamentSelection`) \u2014 we'll make use of that pluggability further down. `stopping_criteria`'s default (stop once the champion hasn't improved for `maxage` generations) is a perfectly sensible rule for a TSP tour too."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Solving the problem\n\nEverything is in place \u2014 let's run it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2026-07-03T19:39:15.707666Z",
     "iopub.status.busy": "2026-07-03T19:39:15.707553Z",
     "iopub.status.idle": "2026-07-03T19:39:15.985179Z",
     "shell.execute_reply": "2026-07-03T19:39:15.984893Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "best tour found: [ 4 14  2  5  6  0 10 12  8 13  7  9  1 11  3]\n",
      "tour length: 410.03967346322673\n"
     ]
    }
   ],
   "source": [
    "ga = PermutationGeneticAlgorithm(\n",
    "    tour_length, n_cities, nPop=60, minimize=True, maxage=30, seed=0\n",
    ")\n",
    "\n",
    "fitness_history = []\n",
    "diversity_history = []\n",
    "for _ in range(120):\n",
    "    ga.evolve(1)\n",
    "    fitness_history.append(ga.champion.fitness)\n",
    "    diversity_history.append(ga.diversity)\n",
    "\n",
    "champion_order = np.asarray(ga.champion.phenotype, dtype=int)\n",
    "print(\"best tour found:\", champion_order)\n",
    "print(\"tour length:\", ga.champion.fitness)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "For context, let's compare against the best of 2000 purely random tours:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2026-07-03T19:39:15.986649Z",
     "iopub.status.busy": "2026-07-03T19:39:15.986559Z",
     "iopub.status.idle": "2026-07-03T19:39:16.015266Z",
     "shell.execute_reply": "2026-07-03T19:39:16.014917Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "best of 2000 random tours: 551.051547282789\n",
      "GA champion:               410.03967346322673\n"
     ]
    }
   ],
   "source": [
    "random_lengths = [tour_length(city_rng.permutation(n_cities)) for _ in range(2000)]\n",
    "print(\"best of 2000 random tours:\", min(random_lengths))\n",
    "print(\"GA champion:              \", ga.champion.fitness)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "And visualize both the resulting tour and the convergence history \u2014 including the **inherited** `diversity` property, which works out of the box because it's computed generically from `self.phenotypes` (the per-dimension standard deviation across the population). It's not the most natural diversity measure for permutations, but it's still informative: a value near zero means the population has collapsed onto very similar orderings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2026-07-03T19:39:16.016805Z",
     "iopub.status.busy": "2026-07-03T19:39:16.016671Z",
     "iopub.status.idle": "2026-07-03T19:39:16.179039Z",
     "shell.execute_reply": "2026-07-03T19:39:16.178574Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1100x450 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tour_points = coords[np.append(champion_order, champion_order[0])]\n",
    "\n",
    "fig, axes = plt.subplots(1, 2, figsize=(11, 4.5))\n",
    "\n",
    "axes[0].plot(tour_points[:, 0], tour_points[:, 1], \"o-\")\n",
    "for i, (x, y) in enumerate(coords):\n",
    "    axes[0].annotate(str(i), (x, y))\n",
    "axes[0].set_title(f\"Best tour found (length={ga.champion.fitness:.1f})\")\n",
    "\n",
    "axes[1].plot(fitness_history, color=\"tab:blue\")\n",
    "axes[1].set_xlabel(\"generation\")\n",
    "axes[1].set_ylabel(\"tour length\", color=\"tab:blue\")\n",
    "ax2 = axes[1].twinx()\n",
    "ax2.plot(diversity_history, color=\"tab:orange\")\n",
    "ax2.set_ylabel(\"diversity\", color=\"tab:orange\")\n",
    "axes[1].set_title(\"Convergence\")\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Reusing the library's pluggability"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Because `select` was left untouched, our brand-new GA already supports every {py:class}`~sigmaepsilon.math.optimize.selection.SelectionStrategy` the library ships with \u2014 no extra code required. Let's rerun with {py:class}`~sigmaepsilon.math.optimize.selection.RankSelection` instead of the default {py:class}`~sigmaepsilon.math.optimize.selection.TournamentSelection`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2026-07-03T19:39:16.180753Z",
     "iopub.status.busy": "2026-07-03T19:39:16.180655Z",
     "iopub.status.idle": "2026-07-03T19:39:16.356372Z",
     "shell.execute_reply": "2026-07-03T19:39:16.356077Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TournamentSelection (default): 410.03967346322673\n",
      "RankSelection:                 419.6873865767511\n"
     ]
    }
   ],
   "source": [
    "ga_rank = PermutationGeneticAlgorithm(\n",
    "    tour_length,\n",
    "    n_cities,\n",
    "    nPop=60,\n",
    "    minimize=True,\n",
    "    maxage=30,\n",
    "    seed=0,\n",
    "    selection_strategy=RankSelection(),\n",
    ")\n",
    "champion_rank = ga_rank.solve()\n",
    "print(\"TournamentSelection (default):\", ga.champion.fitness)\n",
    "print(\"RankSelection:                \", champion_rank.fitness)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Reproducibility comes for free too, via the same `seed` argument every other GA class in the library accepts:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2026-07-03T19:39:16.357925Z",
     "iopub.status.busy": "2026-07-03T19:39:16.357798Z",
     "iopub.status.idle": "2026-07-03T19:39:16.743198Z",
     "shell.execute_reply": "2026-07-03T19:39:16.742893Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ga_a = PermutationGeneticAlgorithm(tour_length, n_cities, nPop=60, minimize=True, maxage=30, seed=7)\n",
    "ga_b = PermutationGeneticAlgorithm(tour_length, n_cities, nPop=60, minimize=True, maxage=30, seed=7)\n",
    "result_a = ga_a.solve()\n",
    "result_b = ga_b.solve()\n",
    "result_a.phenotype == result_b.phenotype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Bonus: overriding a property \u2014 a permutation-aware diversity metric\n\nThe inherited `diversity` property (per-dimension standard deviation of the phenotypes) treats city indices as if they were numbers on a continuous scale, which isn't quite the right notion of \"spread\" for permutations. Since `diversity` is a regular `property`, we can override it just as easily as any method \u2014 here with the average, over all pairs of individuals, of the fraction of positions at which they disagree:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "editable": true,
    "execution": {
     "iopub.execute_input": "2026-07-03T19:39:16.744737Z",
     "iopub.status.busy": "2026-07-03T19:39:16.744606Z",
     "iopub.status.idle": "2026-07-03T19:39:16.761369Z",
     "shell.execute_reply": "2026-07-03T19:39:16.761122Z"
    },
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8228625235404896"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def diversity(self) -> float:\n",
    "    genotypes = np.asarray(self.genotypes)\n",
    "    disagreement = (genotypes[:, None, :] != genotypes[None, :, :]).mean(axis=2)\n",
    "    i, j = np.triu_indices(len(genotypes), k=1)\n",
    "    return float(disagreement[i, j].mean())\n",
    "\n",
    "\n",
    "PermutationGeneticAlgorithm.diversity = property(diversity)\n",
    "\n",
    "ga_custom_diversity = PermutationGeneticAlgorithm(\n",
    "    tour_length, n_cities, nPop=60, minimize=True, maxage=30, seed=0\n",
    ")\n",
    "ga_custom_diversity.evolve(5)\n",
    "ga_custom_diversity.diversity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Recap"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Starting from {py:class}`~sigmaepsilon.math.optimize.ga.GeneticAlgorithm`, a working, reproducible, pluggable-selection genetic algorithm for a genuinely different genotype representation (permutations, not independent boxed variables) took:\n\n- a thin `__init__` override to adapt the constructor's shape to the problem at hand;\n- `populate`, `crossover` (order crossover) and `mutate` (swap mutation) \u2014 the three methods with no meaningful generic default, exactly as the base class's docstring says;\n- optionally, a `diversity` override for a representation-specific notion of population spread.\n\nEverything else \u2014 population-size validation, `elitism`, the per-instance `rng` (and therefore `seed`-based reproducibility), `selection_strategy` (and therefore {py:class}`~sigmaepsilon.math.optimize.selection.TournamentSelection`/{py:class}`~sigmaepsilon.math.optimize.selection.RouletteSelection`/{py:class}`~sigmaepsilon.math.optimize.selection.RankSelection` for free), `vectorized`/`n_jobs` evaluation, champion tracking, `stopping_criteria`, and the whole `evolver`/`evolve`/`solve` loop \u2014 came from {py:class}`~sigmaepsilon.math.optimize.ga.GeneticAlgorithm` unmodified. This is exactly the same recipe {py:class}`~sigmaepsilon.math.optimize.bga.BinaryGeneticAlgorithm`, {py:class}`~sigmaepsilon.math.optimize.iga.IntegerGeneticAlgorithm` and {py:class}`~sigmaepsilon.math.optimize.rga.RealValuedGeneticAlgorithm` follow internally; see their source (`sigmaepsilon/math/optimize/{bga,iga,rga}.py`) for two more worked examples of the same pattern."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "\ud83d\udcd6 {ref}`Genetic Algorithms API Reference <api_optimization_GA>`."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "sigmaepsilon-math-NMVzm02N-py3.12",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}