diff --git a/.gitignore b/.gitignore
index ab14708e1..b498ade87 100644
--- a/.gitignore
+++ b/.gitignore
@@ -233,3 +233,7 @@ Doxyfile
 environment.lock.yml
 refs/
 docs/doxygen_build/
+
+# log files generated by docs/guide/logging.ipynb (and brush's logfile option)
+docs/guide/logs/
+*_simplification_table
diff --git a/docs/guide/index.md b/docs/guide/index.md
index bbc5e43e7..617a9dc4a 100644
--- a/docs/guide/index.md
+++ b/docs/guide/index.md
@@ -18,5 +18,6 @@ saving_loading_populations
 locking_mechanism
 switching_metrics
 archive
+logging
 deap
 ```
diff --git a/docs/guide/logging.ipynb b/docs/guide/logging.ipynb
new file mode 100644
index 000000000..65bd2ab45
--- /dev/null
+++ b/docs/guide/logging.ipynb
@@ -0,0 +1,1875 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ae085022",
+   "metadata": {},
+   "source": [
+    "# Logging the evolution\n",
+    "\n",
+    "Set the `logfile` parameter to a path, and every call to `fit` will write:\n",
+    "\n",
+    "| file | content |\n",
+    "|---|---|\n",
+    "| `<logfile>` | one row per generation: losses, sizes, stall count, archive size, number of evaluations, and the best expression |\n",
+    "| `<logfile>_islands.csv` | the same statistics, one row per island and generation |\n",
+    "| `<logfile>_simplifications.csv` | every replacement performed by the simplifiers (`original` → `replacement`) |\n",
+    "| `<logfile>_simplification_table` | the expressions stored by the inexact simplifier, at the end of the run (only with `inexact_simplification=True`) |\n",
+    "| `<logfile>_runs.jsonl` | one JSON object per run, with the seed and all parameters |\n",
+    "\n",
+    "All files are valid CSV (expressions are quoted) and have a `run_id` column. Files are\n",
+    "opened in append mode, so fitting several times with the same `logfile` adds rows\n",
+    "instead of overwriting them. Brush refuses to append to a file that was written with\n",
+    "different columns (for example, by an older version)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d04218ad",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T16:13:00.220672Z",
+     "iopub.status.busy": "2026-09-23T16:13:00.217928Z",
+     "iopub.status.idle": "2026-09-23T16:13:01.571099Z",
+     "shell.execute_reply": "2026-09-23T16:13:01.570617Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import os, shutil\n",
+    "\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from pybrush import BrushRegressor\n",
+    "\n",
+    "LOG_DIR = \"logs\"\n",
+    "shutil.rmtree(LOG_DIR, ignore_errors=True)\n",
+    "os.makedirs(LOG_DIR, exist_ok=True)\n",
+    "\n",
+    "df = pd.read_csv(\"../examples/datasets/d_enc.csv\")\n",
+    "X = df.drop(columns=\"label\")\n",
+    "y = df[\"label\"]\n",
+    "\n",
+    "pd.set_option(\"display.max_colwidth\", 100)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "774c0cbf",
+   "metadata": {},
+   "source": [
+    "## Generating the log files\n",
+    "\n",
+    "We fit three seeds and write all of them to the **same** `logfile`; the `run_id`\n",
+    "column tells the runs apart."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6aa0c1ae",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T16:13:01.572206Z",
+     "iopub.status.busy": "2026-09-23T16:13:01.572137Z",
+     "iopub.status.idle": "2026-09-23T16:13:10.822828Z",
+     "shell.execute_reply": "2026-09-23T16:13:10.822490Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['brush.csv',\n",
+       " 'brush.csv_islands.csv',\n",
+       " 'brush.csv_runs.jsonl',\n",
+       " 'brush.csv_simplification_table',\n",
+       " 'brush.csv_simplifications.csv']"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "LOGFILE = os.path.join(LOG_DIR, \"brush.csv\")\n",
+    "seeds = [0, 1, 2]\n",
+    "estimators = {}\n",
+    "\n",
+    "for seed in seeds:\n",
+    "    est = BrushRegressor(\n",
+    "        functions=[\"Add\", \"Sub\", \"Mul\", \"Div\", \"Sin\", \"Cos\", \"Exp\", \"Logabs\", \"Sqrtabs\"],\n",
+    "        max_gens=50,\n",
+    "        pop_size=100,\n",
+    "        num_islands=4,\n",
+    "        max_size=50,\n",
+    "        max_depth=6,\n",
+    "        objectives=[\"scorer\", \"linear_complexity\"],\n",
+    "        inexact_simplification=True,\n",
+    "        logfile=LOGFILE, # This toggle on the generation of logfiles\n",
+    "        random_state=seed, # Brush has total random seed control\n",
+    "        verbosity=0,\n",
+    "    )\n",
+    "    est.fit(X, y)\n",
+    "    estimators[seed] = est\n",
+    "\n",
+    "# Files were generated after fitting the estimator\n",
+    "sorted(os.listdir(LOG_DIR))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fb3543b5",
+   "metadata": {},
+   "source": [
+    "## Run metadata\n",
+    "\n",
+    "`_runs.jsonl` has one line per call to `fit`, with the full set of parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d10885f0",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T16:13:10.823843Z",
+     "iopub.status.busy": "2026-09-23T16:13:10.823790Z",
+     "iopub.status.idle": "2026-09-23T16:13:10.830950Z",
+     "shell.execute_reply": "2026-09-23T16:13:10.830644Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>run_id</th>\n",
+       "      <th>random_state</th>\n",
+       "      <th>params.pop_size</th>\n",
+       "      <th>params.max_gens</th>\n",
+       "      <th>params.num_islands</th>\n",
+       "      <th>params.scorer</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>20260923T121716.761-c517</td>\n",
+       "      <td>0</td>\n",
+       "      <td>100</td>\n",
+       "      <td>50</td>\n",
+       "      <td>4</td>\n",
+       "      <td>mse</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>20260923T121720.173-a13f</td>\n",
+       "      <td>1</td>\n",
+       "      <td>100</td>\n",
+       "      <td>50</td>\n",
+       "      <td>4</td>\n",
+       "      <td>mse</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>20260923T121723.647-be9d</td>\n",
+       "      <td>2</td>\n",
+       "      <td>100</td>\n",
+       "      <td>50</td>\n",
+       "      <td>4</td>\n",
+       "      <td>mse</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                     run_id  random_state  params.pop_size  params.max_gens  \\\n",
+       "0  20260923T121716.761-c517             0              100               50   \n",
+       "1  20260923T121720.173-a13f             1              100               50   \n",
+       "2  20260923T121723.647-be9d             2              100               50   \n",
+       "\n",
+       "   params.num_islands params.scorer  \n",
+       "0                   4           mse  \n",
+       "1                   4           mse  \n",
+       "2                   4           mse  "
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "runs = pd.json_normalize(pd.read_json(LOGFILE + \"_runs.jsonl\", lines=True).to_dict(\"records\"))\n",
+    "runs[[\"run_id\", \"random_state\", \"params.pop_size\", \"params.max_gens\", \"params.num_islands\", \"params.scorer\"]]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9a178518",
+   "metadata": {},
+   "source": [
+    "## The evolution log\n",
+    "\n",
+    "Each row is one generation of one run. `best_*` refer to the best individual (chosen on\n",
+    "the validation partition), and `med_*`/`max_*` summarize the whole population.\n",
+    "\n",
+    "`n_evaluations` is cumulative. Models that survived across generations are not\n",
+    "refitted thus not counted towards the number of evaluations.\n",
+    "The number of evaluations refers to the number of times a program was fitted \n",
+    "(had it's weights optimized). It does not reflect the number of optimization\n",
+    "steps performed for each individual."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "3bea9704",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T16:13:10.831806Z",
+     "iopub.status.busy": "2026-09-23T16:13:10.831754Z",
+     "iopub.status.idle": "2026-09-23T16:13:10.835835Z",
+     "shell.execute_reply": "2026-09-23T16:13:10.835510Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "columns: ['run_id', 'random_state', 'generation', 'time', 'best_score', 'best_score_val', 'med_score', 'med_score_val', 'med_size', 'med_complexity', 'max_size', 'max_complexity', 'best_size', 'best_complexity', 'stall_count', 'archive_size', 'n_evaluations', 'best_model']\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>run_id</th>\n",
+       "      <th>random_state</th>\n",
+       "      <th>generation</th>\n",
+       "      <th>time</th>\n",
+       "      <th>best_score</th>\n",
+       "      <th>best_score_val</th>\n",
+       "      <th>med_score</th>\n",
+       "      <th>med_score_val</th>\n",
+       "      <th>med_size</th>\n",
+       "      <th>med_complexity</th>\n",
+       "      <th>max_size</th>\n",
+       "      <th>max_complexity</th>\n",
+       "      <th>best_size</th>\n",
+       "      <th>best_complexity</th>\n",
+       "      <th>stall_count</th>\n",
+       "      <th>archive_size</th>\n",
+       "      <th>n_evaluations</th>\n",
+       "      <th>best_model</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>20260923T121716.761-c517</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.068071</td>\n",
+       "      <td>10.350908</td>\n",
+       "      <td>9.278577</td>\n",
+       "      <td>71.704758</td>\n",
+       "      <td>77.782562</td>\n",
+       "      <td>7</td>\n",
+       "      <td>32</td>\n",
+       "      <td>39</td>\n",
+       "      <td>37237</td>\n",
+       "      <td>39</td>\n",
+       "      <td>5225</td>\n",
+       "      <td>0</td>\n",
+       "      <td>5</td>\n",
+       "      <td>400</td>\n",
+       "      <td>1.62*Add(0.32*Add(109.51*Div(109.30*x3,200.26*Add(225.90*x2,-788.44*Sqrtabs(-3332.07*x4))),31.95...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>20260923T121716.761-c517</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.126026</td>\n",
+       "      <td>9.956403</td>\n",
+       "      <td>9.127022</td>\n",
+       "      <td>20.323715</td>\n",
+       "      <td>21.707689</td>\n",
+       "      <td>6</td>\n",
+       "      <td>25</td>\n",
+       "      <td>42</td>\n",
+       "      <td>37237</td>\n",
+       "      <td>39</td>\n",
+       "      <td>5225</td>\n",
+       "      <td>0</td>\n",
+       "      <td>7</td>\n",
+       "      <td>700</td>\n",
+       "      <td>1.62*Add(0.32*Add(67.72*Div(67.59*x3,302.11*Add(227.53*x2,-783.07*Sqrtabs(-3286.79*x4))),32.25*x...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>20260923T121716.761-c517</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.189985</td>\n",
+       "      <td>9.936137</td>\n",
+       "      <td>9.127022</td>\n",
+       "      <td>17.851387</td>\n",
+       "      <td>19.497444</td>\n",
+       "      <td>7</td>\n",
+       "      <td>27</td>\n",
+       "      <td>45</td>\n",
+       "      <td>8990</td>\n",
+       "      <td>39</td>\n",
+       "      <td>5225</td>\n",
+       "      <td>1</td>\n",
+       "      <td>7</td>\n",
+       "      <td>1000</td>\n",
+       "      <td>1.62*Add(0.32*Add(67.72*Div(67.59*x3,302.11*Add(227.53*x2,-783.07*Sqrtabs(-3286.79*x4))),32.25*x...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>20260923T121716.761-c517</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.244779</td>\n",
+       "      <td>9.934284</td>\n",
+       "      <td>9.127022</td>\n",
+       "      <td>15.598775</td>\n",
+       "      <td>16.937330</td>\n",
+       "      <td>13</td>\n",
+       "      <td>95</td>\n",
+       "      <td>45</td>\n",
+       "      <td>8990</td>\n",
+       "      <td>39</td>\n",
+       "      <td>5225</td>\n",
+       "      <td>2</td>\n",
+       "      <td>9</td>\n",
+       "      <td>1300</td>\n",
+       "      <td>1.62*Add(0.32*Add(67.72*Div(67.59*x3,302.11*Add(227.53*x2,-783.07*Sqrtabs(-3286.79*x4))),32.25*x...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>20260923T121716.761-c517</td>\n",
+       "      <td>0</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0.302656</td>\n",
+       "      <td>9.932689</td>\n",
+       "      <td>9.127022</td>\n",
+       "      <td>15.123131</td>\n",
+       "      <td>16.591620</td>\n",
+       "      <td>13</td>\n",
+       "      <td>107</td>\n",
+       "      <td>43</td>\n",
+       "      <td>8990</td>\n",
+       "      <td>39</td>\n",
+       "      <td>5225</td>\n",
+       "      <td>3</td>\n",
+       "      <td>10</td>\n",
+       "      <td>1600</td>\n",
+       "      <td>1.62*Add(0.32*Add(67.72*Div(67.59*x3,302.11*Add(227.53*x2,-783.07*Sqrtabs(-3286.79*x4))),32.25*x...</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                     run_id  random_state  generation      time  best_score  \\\n",
+       "0  20260923T121716.761-c517             0           0  0.068071   10.350908   \n",
+       "1  20260923T121716.761-c517             0           1  0.126026    9.956403   \n",
+       "2  20260923T121716.761-c517             0           2  0.189985    9.936137   \n",
+       "3  20260923T121716.761-c517             0           3  0.244779    9.934284   \n",
+       "4  20260923T121716.761-c517             0           4  0.302656    9.932689   \n",
+       "\n",
+       "   best_score_val  med_score  med_score_val  med_size  med_complexity  \\\n",
+       "0        9.278577  71.704758      77.782562         7              32   \n",
+       "1        9.127022  20.323715      21.707689         6              25   \n",
+       "2        9.127022  17.851387      19.497444         7              27   \n",
+       "3        9.127022  15.598775      16.937330        13              95   \n",
+       "4        9.127022  15.123131      16.591620        13             107   \n",
+       "\n",
+       "   max_size  max_complexity  best_size  best_complexity  stall_count  \\\n",
+       "0        39           37237         39             5225            0   \n",
+       "1        42           37237         39             5225            0   \n",
+       "2        45            8990         39             5225            1   \n",
+       "3        45            8990         39             5225            2   \n",
+       "4        43            8990         39             5225            3   \n",
+       "\n",
+       "   archive_size  n_evaluations  \\\n",
+       "0             5            400   \n",
+       "1             7            700   \n",
+       "2             7           1000   \n",
+       "3             9           1300   \n",
+       "4            10           1600   \n",
+       "\n",
+       "                                                                                            best_model  \n",
+       "0  1.62*Add(0.32*Add(109.51*Div(109.30*x3,200.26*Add(225.90*x2,-788.44*Sqrtabs(-3332.07*x4))),31.95...  \n",
+       "1  1.62*Add(0.32*Add(67.72*Div(67.59*x3,302.11*Add(227.53*x2,-783.07*Sqrtabs(-3286.79*x4))),32.25*x...  \n",
+       "2  1.62*Add(0.32*Add(67.72*Div(67.59*x3,302.11*Add(227.53*x2,-783.07*Sqrtabs(-3286.79*x4))),32.25*x...  \n",
+       "3  1.62*Add(0.32*Add(67.72*Div(67.59*x3,302.11*Add(227.53*x2,-783.07*Sqrtabs(-3286.79*x4))),32.25*x...  \n",
+       "4  1.62*Add(0.32*Add(67.72*Div(67.59*x3,302.11*Add(227.53*x2,-783.07*Sqrtabs(-3286.79*x4))),32.25*x...  "
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "log = pd.read_csv(LOGFILE)\n",
+    "\n",
+    "print(\"columns:\", list(log.columns))\n",
+    "log.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "f66e118d",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T16:13:10.836598Z",
+     "iopub.status.busy": "2026-09-23T16:13:10.836553Z",
+     "iopub.status.idle": "2026-09-23T16:13:10.842692Z",
+     "shell.execute_reply": "2026-09-23T16:13:10.842376Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>n_generations</th>\n",
+       "      <th>total_time</th>\n",
+       "      <th>n_evaluations</th>\n",
+       "      <th>best_score</th>\n",
+       "      <th>best_score_val</th>\n",
+       "      <th>archive_size</th>\n",
+       "      <th>best_model</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>random_state</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>50</td>\n",
+       "      <td>3.390770</td>\n",
+       "      <td>15100</td>\n",
+       "      <td>5.959468</td>\n",
+       "      <td>6.035597</td>\n",
+       "      <td>15</td>\n",
+       "      <td>Add(0.19*Add(812.02*Div(6852.51*x0,4929.73*Add(185.08*x2,-422.56*Sqrtabs(-3222.37*x4))),82.75*x6...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>50</td>\n",
+       "      <td>3.447640</td>\n",
+       "      <td>15100</td>\n",
+       "      <td>3.812312</td>\n",
+       "      <td>4.720665</td>\n",
+       "      <td>13</td>\n",
+       "      <td>Div(1.39*Exp(0.17*Sin(0.97*Sub(1.84*Add(1.00*x2,-13.06),0.96*x1))),0.56*Div(Sub(0.97*Sqrtabs(Sqr...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>50</td>\n",
+       "      <td>3.329469</td>\n",
+       "      <td>15100</td>\n",
+       "      <td>4.000235</td>\n",
+       "      <td>4.290797</td>\n",
+       "      <td>15</td>\n",
+       "      <td>0.00*Sub(Add(24.98*Mul(2.71*x4,14.29*x6),1387.94*Cos(1.00*Sub(1.56*x4,1.00*Mul(x2,1.00*x1)))),0....</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "              n_generations  total_time  n_evaluations  best_score  \\\n",
+       "random_state                                                         \n",
+       "0                        50    3.390770          15100    5.959468   \n",
+       "1                        50    3.447640          15100    3.812312   \n",
+       "2                        50    3.329469          15100    4.000235   \n",
+       "\n",
+       "              best_score_val  archive_size  \\\n",
+       "random_state                                 \n",
+       "0                   6.035597            15   \n",
+       "1                   4.720665            13   \n",
+       "2                   4.290797            15   \n",
+       "\n",
+       "                                                                                                       best_model  \n",
+       "random_state                                                                                                       \n",
+       "0             Add(0.19*Add(812.02*Div(6852.51*x0,4929.73*Add(185.08*x2,-422.56*Sqrtabs(-3222.37*x4))),82.75*x6...  \n",
+       "1             Div(1.39*Exp(0.17*Sin(0.97*Sub(1.84*Add(1.00*x2,-13.06),0.96*x1))),0.56*Div(Sub(0.97*Sqrtabs(Sqr...  \n",
+       "2             0.00*Sub(Add(24.98*Mul(2.71*x4,14.29*x6),1387.94*Cos(1.00*Sub(1.56*x4,1.00*Mul(x2,1.00*x1)))),0....  "
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# number of generations, best metric and final expression of each run\n",
+    "summary = log.groupby(\"random_state\").agg(\n",
+    "    n_generations=(\"generation\", \"count\"),\n",
+    "    total_time=(\"time\", \"last\"),\n",
+    "    n_evaluations=(\"n_evaluations\", \"last\"),\n",
+    "    best_score=(\"best_score\", \"last\"),\n",
+    "    best_score_val=(\"best_score_val\", \"last\"),\n",
+    "    archive_size=(\"archive_size\", \"last\"),\n",
+    "    best_model=(\"best_model\", \"last\"),\n",
+    ")\n",
+    "summary"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "364c51c1",
+   "metadata": {},
+   "source": [
+    "## Convergence"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "8b0af099",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T16:13:10.843518Z",
+     "iopub.status.busy": "2026-09-23T16:13:10.843472Z",
+     "iopub.status.idle": "2026-09-23T16:13:11.014099Z",
+     "shell.execute_reply": "2026-09-23T16:13:11.013727Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1100x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(1, 2, figsize=(11, 4), sharey=True)\n",
+    "\n",
+    "for seed, l in log.groupby(\"random_state\"):\n",
+    "    axs[0].plot(l[\"generation\"], l[\"best_score\"], label=f\"seed {seed}\")\n",
+    "    axs[1].plot(l[\"generation\"], l[\"best_score_val\"], label=f\"seed {seed}\")\n",
+    "\n",
+    "axs[0].set_title(\"Best individual - train loss\")\n",
+    "axs[1].set_title(\"Best individual - validation loss\")\n",
+    "for ax in axs:\n",
+    "    ax.set_xlabel(\"generation\")\n",
+    "    ax.set_yscale(\"log\")\n",
+    "    ax.grid(alpha=0.3)\n",
+    "axs[0].set_ylabel(\"loss (MSE)\")\n",
+    "axs[1].legend()\n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0b0f83e8",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T16:13:11.014978Z",
+     "iopub.status.busy": "2026-09-23T16:13:11.014929Z",
+     "iopub.status.idle": "2026-09-23T16:13:11.163010Z",
+     "shell.execute_reply": "2026-09-23T16:13:11.162642Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1100x700 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "l = log[log[\"random_state\"] == 0]\n",
+    "fig, axs = plt.subplots(2, 2, figsize=(11, 7))\n",
+    "\n",
+    "axs[0, 0].plot(l[\"generation\"], l[\"best_score\"], label=\"best\")\n",
+    "axs[0, 0].plot(l[\"generation\"], l[\"med_score\"], label=\"median\")\n",
+    "axs[0, 0].set_yscale(\"log\")\n",
+    "axs[0, 0].set_title(\"Train loss\")\n",
+    "axs[0, 0].legend()\n",
+    "\n",
+    "axs[0, 1].plot(l[\"generation\"], l[\"med_size\"], label=\"median\")\n",
+    "axs[0, 1].plot(l[\"generation\"], l[\"max_size\"], label=\"max\")\n",
+    "axs[0, 1].plot(l[\"generation\"], l[\"best_size\"], label=\"best individual\")\n",
+    "axs[0, 1].set_title(\"Program size\")\n",
+    "axs[0, 1].legend()\n",
+    "\n",
+    "axs[1, 0].plot(l[\"generation\"], l[\"stall_count\"], drawstyle=\"steps-post\")\n",
+    "axs[1, 0].set_title(\"Generations without improving the best individual\")\n",
+    "\n",
+    "axs[1, 1].plot(l[\"generation\"], l[\"archive_size\"], drawstyle=\"steps-post\")\n",
+    "axs[1, 1].set_title(\"Archive (Pareto front) size\")\n",
+    "\n",
+    "for ax in axs.flat:\n",
+    "    ax.set_xlabel(\"generation\")\n",
+    "    ax.grid(alpha=0.3)\n",
+    "fig.suptitle(\"seed 0\")\n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "ea785cbd",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T16:13:11.164004Z",
+     "iopub.status.busy": "2026-09-23T16:13:11.163938Z",
+     "iopub.status.idle": "2026-09-23T16:13:11.240575Z",
+     "shell.execute_reply": "2026-09-23T16:13:11.240277Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1100x350 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# cost of the search\n",
+    "fig, axs = plt.subplots(1, 2, figsize=(11, 3.5))\n",
+    "for seed, l in log.groupby(\"random_state\"):\n",
+    "    axs[0].plot(l[\"generation\"], l[\"n_evaluations\"], label=f\"seed {seed}\")\n",
+    "    axs[1].plot(l[\"n_evaluations\"], l[\"best_score_val\"], label=f\"seed {seed}\")\n",
+    "axs[0].set_xlabel(\"generation\")\n",
+    "axs[0].set_ylabel(\"cumulative evaluations\")\n",
+    "axs[1].set_xlabel(\"cumulative evaluations\")\n",
+    "axs[1].set_ylabel(\"best validation loss\")\n",
+    "axs[1].set_yscale(\"log\")\n",
+    "for ax in axs:\n",
+    "    ax.grid(alpha=0.3)\n",
+    "axs[1].legend()\n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "20c2b8e3",
+   "metadata": {},
+   "source": [
+    "## Best expression over the generations\n",
+    "\n",
+    "The `best_model` column shows how the best individual changed. We keep only the\n",
+    "generations where it changed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "9f707acd",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T16:13:11.241608Z",
+     "iopub.status.busy": "2026-09-23T16:13:11.241558Z",
+     "iopub.status.idle": "2026-09-23T16:13:11.244969Z",
+     "shell.execute_reply": "2026-09-23T16:13:11.244589Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>generation</th>\n",
+       "      <th>best_score_val</th>\n",
+       "      <th>best_size</th>\n",
+       "      <th>best_model</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>9.278577</td>\n",
+       "      <td>39</td>\n",
+       "      <td>1.62*Add(0.32*Add(109.51*Div(109.30*x3,200.26*Add(225.90*x2,-788.44*Sqrtabs(-3332.07*x4))),31.95...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1</td>\n",
+       "      <td>9.127022</td>\n",
+       "      <td>39</td>\n",
+       "      <td>1.62*Add(0.32*Add(67.72*Div(67.59*x3,302.11*Add(227.53*x2,-783.07*Sqrtabs(-3286.79*x4))),32.25*x...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>8</td>\n",
+       "      <td>8.810316</td>\n",
+       "      <td>45</td>\n",
+       "      <td>0.69*Add(0.43*Add(970.14*Div(48.11*x3,-381.89*Add(230.46*x2,-762.89*Sqrtabs(-3304.37*x4))),55.19...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>9</td>\n",
+       "      <td>8.810287</td>\n",
+       "      <td>43</td>\n",
+       "      <td>0.70*Add(23.25*Add(332.12*Div(16.47*x3,-2464.26*Add(231.03*x2,-763.86*Sqrtabs(-3312.69*x4))),x6)...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>10</td>\n",
+       "      <td>8.810237</td>\n",
+       "      <td>45</td>\n",
+       "      <td>0.68*Add(0.43*Add(965.64*Div(48.34*x3,-383.90*Add(230.41*x2,-762.89*Sqrtabs(-3302.95*x4))),54.92...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>11</td>\n",
+       "      <td>7.319740</td>\n",
+       "      <td>45</td>\n",
+       "      <td>0.68*Add(0.43*Add(2659.25*Div(16753.25*x0,3640.52*Add(185.45*x2,-421.66*Sqrtabs(-3207.36*x4))),5...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>12</td>\n",
+       "      <td>6.632836</td>\n",
+       "      <td>45</td>\n",
+       "      <td>0.67*Add(0.41*Add(1756.35*Div(11066.24*x0,5321.64*Add(185.13*x2,-422.40*Sqrtabs(-3218.61*x4))),5...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>13</td>\n",
+       "      <td>6.288856</td>\n",
+       "      <td>45</td>\n",
+       "      <td>0.68*Add(0.40*Add(1699.36*Div(10700.80*x0,5499.05*Add(185.11*x2,-422.43*Sqrtabs(-3219.07*x4))),5...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>14</td>\n",
+       "      <td>6.271890</td>\n",
+       "      <td>45</td>\n",
+       "      <td>0.36*Add(4.50*Add(-1149.91*Div(-5750.37*x0,11909.45*Add(185.11*x2,-422.35*Sqrtabs(-3220.11*x4)))...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>15</td>\n",
+       "      <td>6.192916</td>\n",
+       "      <td>49</td>\n",
+       "      <td>0.45*Add(0.22*Add(2058.68*Div(16604.21*x0,4962.30*Add(185.08*x2,-422.45*Sqrtabs(-3219.49*x4))),0...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>25</th>\n",
+       "      <td>25</td>\n",
+       "      <td>6.168351</td>\n",
+       "      <td>49</td>\n",
+       "      <td>0.27*Add(0.54*Add(1827.21*Div(12099.95*x0,4751.91*Add(185.10*x2,-422.49*Sqrtabs(-3219.78*x4))),1...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>29</th>\n",
+       "      <td>29</td>\n",
+       "      <td>6.158276</td>\n",
+       "      <td>49</td>\n",
+       "      <td>0.22*Add(0.57*Add(1877.77*Div(12344.38*x0,4546.73*Add(185.09*x2,-422.49*Sqrtabs(-3219.77*x4))),1...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>31</th>\n",
+       "      <td>31</td>\n",
+       "      <td>6.138827</td>\n",
+       "      <td>48</td>\n",
+       "      <td>1.92*Add(0.17*Add(1274.97*Div(9031.33*x0,5986.33*Add(185.10*x2,-422.48*Sqrtabs(-3220.48*x4))),4....</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>46</th>\n",
+       "      <td>46</td>\n",
+       "      <td>6.138803</td>\n",
+       "      <td>42</td>\n",
+       "      <td>1.54*Add(0.20*Add(1276.03*Div(9249.64*x0,5857.35*Add(185.10*x2,-422.48*Sqrtabs(-3220.58*x4))),53...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>48</th>\n",
+       "      <td>48</td>\n",
+       "      <td>6.035705</td>\n",
+       "      <td>50</td>\n",
+       "      <td>1.75*Add(0.16*Add(892.99*Div(6962.25*x0,8090.15*Add(185.08*x2,-422.56*Sqrtabs(-3222.30*x4))),56....</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>49</th>\n",
+       "      <td>49</td>\n",
+       "      <td>6.035597</td>\n",
+       "      <td>48</td>\n",
+       "      <td>Add(0.19*Add(812.02*Div(6852.51*x0,4929.73*Add(185.08*x2,-422.56*Sqrtabs(-3222.37*x4))),82.75*x6...</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    generation  best_score_val  best_size  \\\n",
+       "0            0        9.278577         39   \n",
+       "1            1        9.127022         39   \n",
+       "8            8        8.810316         45   \n",
+       "9            9        8.810287         43   \n",
+       "10          10        8.810237         45   \n",
+       "11          11        7.319740         45   \n",
+       "12          12        6.632836         45   \n",
+       "13          13        6.288856         45   \n",
+       "14          14        6.271890         45   \n",
+       "15          15        6.192916         49   \n",
+       "25          25        6.168351         49   \n",
+       "29          29        6.158276         49   \n",
+       "31          31        6.138827         48   \n",
+       "46          46        6.138803         42   \n",
+       "48          48        6.035705         50   \n",
+       "49          49        6.035597         48   \n",
+       "\n",
+       "                                                                                             best_model  \n",
+       "0   1.62*Add(0.32*Add(109.51*Div(109.30*x3,200.26*Add(225.90*x2,-788.44*Sqrtabs(-3332.07*x4))),31.95...  \n",
+       "1   1.62*Add(0.32*Add(67.72*Div(67.59*x3,302.11*Add(227.53*x2,-783.07*Sqrtabs(-3286.79*x4))),32.25*x...  \n",
+       "8   0.69*Add(0.43*Add(970.14*Div(48.11*x3,-381.89*Add(230.46*x2,-762.89*Sqrtabs(-3304.37*x4))),55.19...  \n",
+       "9   0.70*Add(23.25*Add(332.12*Div(16.47*x3,-2464.26*Add(231.03*x2,-763.86*Sqrtabs(-3312.69*x4))),x6)...  \n",
+       "10  0.68*Add(0.43*Add(965.64*Div(48.34*x3,-383.90*Add(230.41*x2,-762.89*Sqrtabs(-3302.95*x4))),54.92...  \n",
+       "11  0.68*Add(0.43*Add(2659.25*Div(16753.25*x0,3640.52*Add(185.45*x2,-421.66*Sqrtabs(-3207.36*x4))),5...  \n",
+       "12  0.67*Add(0.41*Add(1756.35*Div(11066.24*x0,5321.64*Add(185.13*x2,-422.40*Sqrtabs(-3218.61*x4))),5...  \n",
+       "13  0.68*Add(0.40*Add(1699.36*Div(10700.80*x0,5499.05*Add(185.11*x2,-422.43*Sqrtabs(-3219.07*x4))),5...  \n",
+       "14  0.36*Add(4.50*Add(-1149.91*Div(-5750.37*x0,11909.45*Add(185.11*x2,-422.35*Sqrtabs(-3220.11*x4)))...  \n",
+       "15  0.45*Add(0.22*Add(2058.68*Div(16604.21*x0,4962.30*Add(185.08*x2,-422.45*Sqrtabs(-3219.49*x4))),0...  \n",
+       "25  0.27*Add(0.54*Add(1827.21*Div(12099.95*x0,4751.91*Add(185.10*x2,-422.49*Sqrtabs(-3219.78*x4))),1...  \n",
+       "29  0.22*Add(0.57*Add(1877.77*Div(12344.38*x0,4546.73*Add(185.09*x2,-422.49*Sqrtabs(-3219.77*x4))),1...  \n",
+       "31  1.92*Add(0.17*Add(1274.97*Div(9031.33*x0,5986.33*Add(185.10*x2,-422.48*Sqrtabs(-3220.48*x4))),4....  \n",
+       "46  1.54*Add(0.20*Add(1276.03*Div(9249.64*x0,5857.35*Add(185.10*x2,-422.48*Sqrtabs(-3220.58*x4))),53...  \n",
+       "48  1.75*Add(0.16*Add(892.99*Div(6962.25*x0,8090.15*Add(185.08*x2,-422.56*Sqrtabs(-3222.30*x4))),56....  \n",
+       "49  Add(0.19*Add(812.02*Div(6852.51*x0,4929.73*Add(185.08*x2,-422.56*Sqrtabs(-3222.37*x4))),82.75*x6...  "
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "l = log[log[\"random_state\"] == 0]\n",
+    "changes = l[l[\"best_model\"] != l[\"best_model\"].shift()]\n",
+    "changes[[\"generation\", \"best_score_val\", \"best_size\", \"best_model\"]]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d19980e3",
+   "metadata": {},
+   "source": [
+    "## Per-island statistics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "7c2c4456",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T16:13:11.245830Z",
+     "iopub.status.busy": "2026-09-23T16:13:11.245786Z",
+     "iopub.status.idle": "2026-09-23T16:13:11.336097Z",
+     "shell.execute_reply": "2026-09-23T16:13:11.335782Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "columns: ['run_id', 'generation', 'island', 'n_individuals', 'best_score', 'best_score_val', 'med_score', 'med_score_val', 'med_size', 'med_complexity', 'max_size', 'max_complexity']\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1100x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "islands = pd.read_csv(LOGFILE + \"_islands.csv\")\n",
+    "print(\"columns:\", list(islands.columns))\n",
+    "\n",
+    "isl = islands[islands[\"run_id\"] == runs.loc[runs[\"random_state\"] == 0, \"run_id\"].iloc[0]]\n",
+    "\n",
+    "fig, axs = plt.subplots(1, 2, figsize=(11, 4))\n",
+    "for island, g in isl.groupby(\"island\"):\n",
+    "    axs[0].plot(g[\"generation\"], g[\"best_score\"], label=f\"island {island}\")\n",
+    "    axs[1].plot(g[\"generation\"], g[\"med_size\"], label=f\"island {island}\")\n",
+    "axs[0].set_title(\"Best train loss per island (seed 0)\")\n",
+    "axs[0].set_yscale(\"log\")\n",
+    "axs[1].set_title(\"Median size per island (seed 0)\")\n",
+    "for ax in axs:\n",
+    "    ax.set_xlabel(\"generation\")\n",
+    "    ax.grid(alpha=0.3)\n",
+    "axs[1].legend()\n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1993d011",
+   "metadata": {},
+   "source": [
+    "## Final Pareto fronts\n",
+    "\n",
+    "The CSV logs only keep the best individual. The whole front (extracted right before the last valid generation) is available from the\n",
+    "fitted estimator (`archive_`)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "9978968b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T16:13:11.337095Z",
+     "iopub.status.busy": "2026-09-23T16:13:11.337043Z",
+     "iopub.status.idle": "2026-09-23T16:13:11.340947Z",
+     "shell.execute_reply": "2026-09-23T16:13:11.340659Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>size</th>\n",
+       "      <th>complexity</th>\n",
+       "      <th>val_loss</th>\n",
+       "      <th>model</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>2</td>\n",
+       "      <td>97.703964</td>\n",
+       "      <td>24.17</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>3</td>\n",
+       "      <td>5</td>\n",
+       "      <td>19.342838</td>\n",
+       "      <td>4.60*x4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>7</td>\n",
+       "      <td>13</td>\n",
+       "      <td>14.473068</td>\n",
+       "      <td>11.41*Add(0.37*x4,x6)</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>10</td>\n",
+       "      <td>20</td>\n",
+       "      <td>12.181124</td>\n",
+       "      <td>6.69*Exp(Sub(0.21*x4,-0.63*x6))</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>11</td>\n",
+       "      <td>21</td>\n",
+       "      <td>10.951211</td>\n",
+       "      <td>Sub(5.61*x4,Sub(-17.91*x6,-11.82*x0))</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>11</td>\n",
+       "      <td>25</td>\n",
+       "      <td>10.312360</td>\n",
+       "      <td>Sub(-10.30,0.01*Mul(Sub(-338.44*x6,x1),x4))</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>13</td>\n",
+       "      <td>28</td>\n",
+       "      <td>9.265789</td>\n",
+       "      <td>Sub(-0.03*x3,0.01*Mul(Sub(-380.14*x6,x1),x4))</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>15</td>\n",
+       "      <td>30</td>\n",
+       "      <td>9.265786</td>\n",
+       "      <td>Sub(-0.03*x3,0.07*Mul(Sub(-42.68*x6,0.11*x1),x4))</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>17</td>\n",
+       "      <td>32</td>\n",
+       "      <td>9.265783</td>\n",
+       "      <td>Sub(-0.03*x3,0.09*Mul(Sub(-55.68*x6,0.15*x1),0.61*x4))</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>23</td>\n",
+       "      <td>45</td>\n",
+       "      <td>8.871875</td>\n",
+       "      <td>0.15*Sub(-1217.18,Mul(2.08*Add(Sub(-56.72*x6,1.17*x1),0.21*x3),Sub(x0,-0.02*x4)))</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>27</td>\n",
+       "      <td>49</td>\n",
+       "      <td>8.869665</td>\n",
+       "      <td>0.22*Sub(-837.32,Mul(0.84*Add(Sub(-24.64*x6,0.51*x1),0.09*x3),0.44*Sub(8.90*x0,-0.21*x4)))</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>32</td>\n",
+       "      <td>60</td>\n",
+       "      <td>7.998517</td>\n",
+       "      <td>0.66*Add(0.02*Add(31.71*Div(1.43*x2,Add(185.08*x2,-422.53*Sqrtabs(-3221.28*x4))),1048.94*x6),Add...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>36</td>\n",
+       "      <td>68</td>\n",
+       "      <td>6.334166</td>\n",
+       "      <td>3.00*Add(0.37*Add(965.81*Div(8205.08*x0,8424.49*Add(185.03*x2,-422.31*Sqrtabs(-3216.79*x4))),14....</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>40</td>\n",
+       "      <td>75</td>\n",
+       "      <td>6.138934</td>\n",
+       "      <td>1.46*Add(Add(729.70*Div(5337.57*x0,9268.67*Add(185.10*x2,-422.49*Sqrtabs(-3220.58*x4))),11.07*x6...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>48</td>\n",
+       "      <td>87</td>\n",
+       "      <td>6.035597</td>\n",
+       "      <td>Add(0.19*Add(812.02*Div(6852.51*x0,4929.73*Add(185.08*x2,-422.56*Sqrtabs(-3222.37*x4))),82.75*x6...</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    size  complexity   val_loss  \\\n",
+       "0      1           2  97.703964   \n",
+       "1      3           5  19.342838   \n",
+       "2      7          13  14.473068   \n",
+       "3     10          20  12.181124   \n",
+       "4     11          21  10.951211   \n",
+       "5     11          25  10.312360   \n",
+       "6     13          28   9.265789   \n",
+       "7     15          30   9.265786   \n",
+       "8     17          32   9.265783   \n",
+       "9     23          45   8.871875   \n",
+       "10    27          49   8.869665   \n",
+       "11    32          60   7.998517   \n",
+       "12    36          68   6.334166   \n",
+       "13    40          75   6.138934   \n",
+       "14    48          87   6.035597   \n",
+       "\n",
+       "                                                                                                  model  \n",
+       "0                                                                                                 24.17  \n",
+       "1                                                                                               4.60*x4  \n",
+       "2                                                                                 11.41*Add(0.37*x4,x6)  \n",
+       "3                                                                       6.69*Exp(Sub(0.21*x4,-0.63*x6))  \n",
+       "4                                                                 Sub(5.61*x4,Sub(-17.91*x6,-11.82*x0))  \n",
+       "5                                                           Sub(-10.30,0.01*Mul(Sub(-338.44*x6,x1),x4))  \n",
+       "6                                                         Sub(-0.03*x3,0.01*Mul(Sub(-380.14*x6,x1),x4))  \n",
+       "7                                                     Sub(-0.03*x3,0.07*Mul(Sub(-42.68*x6,0.11*x1),x4))  \n",
+       "8                                                Sub(-0.03*x3,0.09*Mul(Sub(-55.68*x6,0.15*x1),0.61*x4))  \n",
+       "9                     0.15*Sub(-1217.18,Mul(2.08*Add(Sub(-56.72*x6,1.17*x1),0.21*x3),Sub(x0,-0.02*x4)))  \n",
+       "10           0.22*Sub(-837.32,Mul(0.84*Add(Sub(-24.64*x6,0.51*x1),0.09*x3),0.44*Sub(8.90*x0,-0.21*x4)))  \n",
+       "11  0.66*Add(0.02*Add(31.71*Div(1.43*x2,Add(185.08*x2,-422.53*Sqrtabs(-3221.28*x4))),1048.94*x6),Add...  \n",
+       "12  3.00*Add(0.37*Add(965.81*Div(8205.08*x0,8424.49*Add(185.03*x2,-422.31*Sqrtabs(-3216.79*x4))),14....  \n",
+       "13  1.46*Add(Add(729.70*Div(5337.57*x0,9268.67*Add(185.10*x2,-422.49*Sqrtabs(-3220.58*x4))),11.07*x6...  \n",
+       "14  Add(0.19*Add(812.02*Div(6852.51*x0,4929.73*Add(185.08*x2,-422.56*Sqrtabs(-3222.37*x4))),82.75*x6...  "
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "front = pd.DataFrame([\n",
+    "    {\n",
+    "        \"size\": ind.program.size(),\n",
+    "        \"complexity\": ind.program.linear_complexity(),\n",
+    "        \"val_loss\": ind.fitness.loss_v,\n",
+    "        \"model\": ind.program.get_model(),\n",
+    "    }\n",
+    "    for ind in estimators[0].archive_\n",
+    "]).sort_values(\"complexity\")\n",
+    "front"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "88d7ee96",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T16:13:11.341827Z",
+     "iopub.status.busy": "2026-09-23T16:13:11.341782Z",
+     "iopub.status.idle": "2026-09-23T16:13:11.396157Z",
+     "shell.execute_reply": "2026-09-23T16:13:11.395845Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(6, 4))\n",
+    "for seed, e in estimators.items():\n",
+    "    pts = sorted((i.program.linear_complexity(), i.fitness.loss_v) for i in e.archive_)\n",
+    "    ax.step(*zip(*pts), where=\"post\", marker=\"o\", label=f\"seed {seed}\")\n",
+    "ax.set_xscale(\"log\")\n",
+    "ax.set_yscale(\"log\")\n",
+    "ax.xaxis.set_minor_formatter(plt.NullFormatter())\n",
+    "ax.set_xlabel(\"linear complexity\")\n",
+    "ax.set_ylabel(\"validation loss\")\n",
+    "ax.set_title(\"Final Pareto fronts\")\n",
+    "ax.legend()\n",
+    "ax.grid(alpha=0.3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b5fe959a",
+   "metadata": {},
+   "source": [
+    "## Simplifications\n",
+    "\n",
+    "Each row of `_simplifications.csv` is one replacement made in an offspring:\n",
+    "\n",
+    "- `constants`: a subtree with (almost) constant output was replaced by a constant;\n",
+    "- `inexact`: a subtree was replaced by a smaller one with (almost) the same output,\n",
+    "  found with locality-sensitive hashing. `distance` is the MSE between the predictions\n",
+    "  of the program before and after the replacement."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "72dcf422",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T16:13:11.397133Z",
+     "iopub.status.busy": "2026-09-23T16:13:11.397076Z",
+     "iopub.status.idle": "2026-09-23T16:13:11.403743Z",
+     "shell.execute_reply": "2026-09-23T16:13:11.403405Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "columns: ['run_id', 'generation', 'individual_id', 'simplifier', 'ret_type', 'original', 'replacement', 'distance']\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th>simplifier</th>\n",
+       "      <th>constants</th>\n",
+       "      <th>inexact</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>run_id</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>20260923T121716.761-c517</th>\n",
+       "      <td>244</td>\n",
+       "      <td>102</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>20260923T121720.173-a13f</th>\n",
+       "      <td>180</td>\n",
+       "      <td>98</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>20260923T121723.647-be9d</th>\n",
+       "      <td>175</td>\n",
+       "      <td>114</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "simplifier                constants  inexact\n",
+       "run_id                                      \n",
+       "20260923T121716.761-c517        244      102\n",
+       "20260923T121720.173-a13f        180       98\n",
+       "20260923T121723.647-be9d        175      114"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "simp = pd.read_csv(LOGFILE + \"_simplifications.csv\")\n",
+    "print(\"columns:\", list(simp.columns))\n",
+    "simp.groupby([\"run_id\", \"simplifier\"]).size().unstack(fill_value=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "54f2530e",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T16:13:11.404603Z",
+     "iopub.status.busy": "2026-09-23T16:13:11.404551Z",
+     "iopub.status.idle": "2026-09-23T16:13:11.482260Z",
+     "shell.execute_reply": "2026-09-23T16:13:11.481908Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1100x350 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "counts = simp.groupby([\"generation\", \"simplifier\"]).size().unstack(fill_value=0)\n",
+    "counts = counts.reindex(range(log[\"generation\"].max() + 1), fill_value=0)\n",
+    "ax = counts.plot(kind=\"bar\", stacked=True, figsize=(11, 3.5), width=0.9)\n",
+    "ax.set_ylabel(\"replacements (all runs)\")\n",
+    "ax.set_xticks(range(0, len(counts), 5), labels=range(0, len(counts), 5), rotation=0)\n",
+    "ax.grid(alpha=0.3, axis=\"y\")\n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2f1ea287",
+   "metadata": {},
+   "source": [
+    "### Some examples\n",
+    "\n",
+    "The inexact replacements that removed the most (by expression length):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "b086414e",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T16:13:11.483204Z",
+     "iopub.status.busy": "2026-09-23T16:13:11.483150Z",
+     "iopub.status.idle": "2026-09-23T16:13:11.486866Z",
+     "shell.execute_reply": "2026-09-23T16:13:11.486559Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>generation</th>\n",
+       "      <th>individual_id</th>\n",
+       "      <th>original</th>\n",
+       "      <th>replacement</th>\n",
+       "      <th>distance</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>406</th>\n",
+       "      <td>23</td>\n",
+       "      <td>2404</td>\n",
+       "      <td>Add(620.09*Exp(-9071.97*Div(-9068.50*x0,-19514.49*x3)),2.01*Cos(0.96*Add(0.96*x3,9.61*x6)))</td>\n",
+       "      <td>2.01*Cos(0.96*Add(0.96*x3,9.61*x6))</td>\n",
+       "      <td>2.754639e-06</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>477</th>\n",
+       "      <td>31</td>\n",
+       "      <td>3281</td>\n",
+       "      <td>Add(0.01*Mul(0.02*x4,0.05*Add(-433.39*x6,0.05*x2)),-1.12*Sin(-46.28*x0))</td>\n",
+       "      <td>-1.12*Sin(-46.28*x0)</td>\n",
+       "      <td>4.804618e-06</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>747</th>\n",
+       "      <td>26</td>\n",
+       "      <td>2754</td>\n",
+       "      <td>1.00*Sub(1.00*x2,1.14*Sub(3.65*x0,-1.01*Logabs(-0.63*x4)))</td>\n",
+       "      <td>Sub(x2,x4)</td>\n",
+       "      <td>4.830749e-06</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>593</th>\n",
+       "      <td>46</td>\n",
+       "      <td>4727</td>\n",
+       "      <td>Add(Mul(-0.00*Sub(0.00*x1,4.43*x6),0.00*x3),x0)</td>\n",
+       "      <td>x0</td>\n",
+       "      <td>1.637908e-06</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>618</th>\n",
+       "      <td>49</td>\n",
+       "      <td>5057</td>\n",
+       "      <td>1.87*Div(Sub(Sqrtabs(2.10*x0),0.01*x6),Add(1.74*x0,-1.23*x0))</td>\n",
+       "      <td>Div(Logabs(x1),1.00)</td>\n",
+       "      <td>1.941102e-06</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>377</th>\n",
+       "      <td>2</td>\n",
+       "      <td>368</td>\n",
+       "      <td>0.97*Add(0.70*Sqrtabs(0.37*x0),1.06*Add(1.12*x4,1.12*x4))</td>\n",
+       "      <td>Add(1.22*x4,1.22*x4)</td>\n",
+       "      <td>3.768802e-06</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>870</th>\n",
+       "      <td>43</td>\n",
+       "      <td>4428</td>\n",
+       "      <td>1.26*Sub(1.93*x4,3.17*Div(x2,-2.06*x1))</td>\n",
+       "      <td>x4</td>\n",
+       "      <td>4.058915e-06</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>634</th>\n",
+       "      <td>0</td>\n",
+       "      <td>157</td>\n",
+       "      <td>Add(-2373540.50*Cos(5477914.00*x4),-2411207.25*Sub(5827149.00*x4,110628.20*x1))</td>\n",
+       "      <td>-2411207.25*Sub(5827149.00*x4,110628.20*x1)</td>\n",
+       "      <td>1.877450e-16</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>61</th>\n",
+       "      <td>11</td>\n",
+       "      <td>1207</td>\n",
+       "      <td>0.95*Add(0.97*Div(0.97*x4,1.03*x0),0.95*Div(0.95*x3,1.05*x0))</td>\n",
+       "      <td>2.13*Div(2.13*x3,0.31*x0)</td>\n",
+       "      <td>4.574575e-08</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>843</th>\n",
+       "      <td>39</td>\n",
+       "      <td>4060</td>\n",
+       "      <td>0.81*Add(0.47*Mul(0.47*x3,0.13),0.73*x2)</td>\n",
+       "      <td>Sub(x2,x4)</td>\n",
+       "      <td>7.030044e-06</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     generation  individual_id  \\\n",
+       "406          23           2404   \n",
+       "477          31           3281   \n",
+       "747          26           2754   \n",
+       "593          46           4727   \n",
+       "618          49           5057   \n",
+       "377           2            368   \n",
+       "870          43           4428   \n",
+       "634           0            157   \n",
+       "61           11           1207   \n",
+       "843          39           4060   \n",
+       "\n",
+       "                                                                                        original  \\\n",
+       "406  Add(620.09*Exp(-9071.97*Div(-9068.50*x0,-19514.49*x3)),2.01*Cos(0.96*Add(0.96*x3,9.61*x6)))   \n",
+       "477                     Add(0.01*Mul(0.02*x4,0.05*Add(-433.39*x6,0.05*x2)),-1.12*Sin(-46.28*x0))   \n",
+       "747                                   1.00*Sub(1.00*x2,1.14*Sub(3.65*x0,-1.01*Logabs(-0.63*x4)))   \n",
+       "593                                              Add(Mul(-0.00*Sub(0.00*x1,4.43*x6),0.00*x3),x0)   \n",
+       "618                                1.87*Div(Sub(Sqrtabs(2.10*x0),0.01*x6),Add(1.74*x0,-1.23*x0))   \n",
+       "377                                    0.97*Add(0.70*Sqrtabs(0.37*x0),1.06*Add(1.12*x4,1.12*x4))   \n",
+       "870                                                      1.26*Sub(1.93*x4,3.17*Div(x2,-2.06*x1))   \n",
+       "634              Add(-2373540.50*Cos(5477914.00*x4),-2411207.25*Sub(5827149.00*x4,110628.20*x1))   \n",
+       "61                                 0.95*Add(0.97*Div(0.97*x4,1.03*x0),0.95*Div(0.95*x3,1.05*x0))   \n",
+       "843                                                     0.81*Add(0.47*Mul(0.47*x3,0.13),0.73*x2)   \n",
+       "\n",
+       "                                     replacement      distance  \n",
+       "406          2.01*Cos(0.96*Add(0.96*x3,9.61*x6))  2.754639e-06  \n",
+       "477                         -1.12*Sin(-46.28*x0)  4.804618e-06  \n",
+       "747                                   Sub(x2,x4)  4.830749e-06  \n",
+       "593                                           x0  1.637908e-06  \n",
+       "618                         Div(Logabs(x1),1.00)  1.941102e-06  \n",
+       "377                         Add(1.22*x4,1.22*x4)  3.768802e-06  \n",
+       "870                                           x4  4.058915e-06  \n",
+       "634  -2411207.25*Sub(5827149.00*x4,110628.20*x1)  1.877450e-16  \n",
+       "61                     2.13*Div(2.13*x3,0.31*x0)  4.574575e-08  \n",
+       "843                                   Sub(x2,x4)  7.030044e-06  "
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "inexact = simp[simp[\"simplifier\"] == \"inexact\"].copy()\n",
+    "inexact[\"saved_chars\"] = inexact[\"original\"].str.len() - inexact[\"replacement\"].str.len()\n",
+    "inexact.sort_values(\"saved_chars\", ascending=False)[\n",
+    "    [\"generation\", \"individual_id\", \"original\", \"replacement\", \"distance\"]\n",
+    "].head(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "29f7084d",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T16:13:11.487726Z",
+     "iopub.status.busy": "2026-09-23T16:13:11.487682Z",
+     "iopub.status.idle": "2026-09-23T16:13:11.490325Z",
+     "shell.execute_reply": "2026-09-23T16:13:11.490065Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>generation</th>\n",
+       "      <th>original</th>\n",
+       "      <th>replacement</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>Exp(Mul(Add(Cos(x3),Add(x2,x6)),Sub(1.00,373.44*Sqrtabs(555.29*x4))))</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0</td>\n",
+       "      <td>-2.98*Div(-2.92*x0,5.92*x0)</td>\n",
+       "      <td>1.47</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0.13*Mul(0.06,0.19*x0)</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0</td>\n",
+       "      <td>-0.23*Mul(-1.27,-0.23)</td>\n",
+       "      <td>-0.07</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0</td>\n",
+       "      <td>-38.37*Sin(-5.00)</td>\n",
+       "      <td>-36.82</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>0</td>\n",
+       "      <td>Sub(x2,x2)</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>0</td>\n",
+       "      <td>1.50*Sin(1.69)</td>\n",
+       "      <td>1.49</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>0</td>\n",
+       "      <td>2.51*Exp(Mul(Exp(x0),Mul(Mul(x1,x2),Sin(Logabs(x2)))))</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>0</td>\n",
+       "      <td>12.85*Logabs(31326.93)</td>\n",
+       "      <td>133.03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>0</td>\n",
+       "      <td>Sub(x2,x2)</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   generation  \\\n",
+       "0           0   \n",
+       "1           0   \n",
+       "2           0   \n",
+       "3           0   \n",
+       "4           0   \n",
+       "5           0   \n",
+       "6           0   \n",
+       "7           0   \n",
+       "8           0   \n",
+       "9           0   \n",
+       "\n",
+       "                                                                original  \\\n",
+       "0  Exp(Mul(Add(Cos(x3),Add(x2,x6)),Sub(1.00,373.44*Sqrtabs(555.29*x4))))   \n",
+       "1                                            -2.98*Div(-2.92*x0,5.92*x0)   \n",
+       "2                                                 0.13*Mul(0.06,0.19*x0)   \n",
+       "3                                                 -0.23*Mul(-1.27,-0.23)   \n",
+       "4                                                      -38.37*Sin(-5.00)   \n",
+       "5                                                             Sub(x2,x2)   \n",
+       "6                                                         1.50*Sin(1.69)   \n",
+       "7                 2.51*Exp(Mul(Exp(x0),Mul(Mul(x1,x2),Sin(Logabs(x2)))))   \n",
+       "8                                                 12.85*Logabs(31326.93)   \n",
+       "9                                                             Sub(x2,x2)   \n",
+       "\n",
+       "  replacement  \n",
+       "0        0.00  \n",
+       "1        1.47  \n",
+       "2        0.00  \n",
+       "3       -0.07  \n",
+       "4      -36.82  \n",
+       "5        0.00  \n",
+       "6        1.49  \n",
+       "7        0.00  \n",
+       "8      133.03  \n",
+       "9        0.00  "
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "simp[simp[\"simplifier\"] == \"constants\"][[\"generation\", \"original\", \"replacement\"]].head(10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "99b48b64",
+   "metadata": {},
+   "source": [
+    "The replaced subtrees are not identical: the inexact simplifier compares centered\n",
+    "predictions, so a replacement may differ by an offset or scale that the program's weights\n",
+    "absorb. `distance` records how little the predictions of the whole program changed.\n",
+    "\n",
+    "## The simplification table\n",
+    "\n",
+    "`_simplification_table` is a dump of every expression stored by the inexact simplifier\n",
+    "at the end of each run. Expressions sharing `(DataType, Plane, Key)` are candidates to\n",
+    "replace each other."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "355f35d3",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T16:13:11.491197Z",
+     "iopub.status.busy": "2026-09-23T16:13:11.491155Z",
+     "iopub.status.idle": "2026-09-23T16:13:11.497826Z",
+     "shell.execute_reply": "2026-09-23T16:13:11.497507Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "columns: ['run_id', 'DataType', 'Plane', 'Key', 'Tree']\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th>DataType</th>\n",
+       "      <th>ArrayB</th>\n",
+       "      <th>ArrayF</th>\n",
+       "      <th>ArrayI</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>run_id</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>20260923T121716.761-c517</th>\n",
+       "      <td>1</td>\n",
+       "      <td>2758</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>20260923T121720.173-a13f</th>\n",
+       "      <td>1</td>\n",
+       "      <td>3062</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>20260923T121723.647-be9d</th>\n",
+       "      <td>1</td>\n",
+       "      <td>2619</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "DataType                  ArrayB  ArrayF  ArrayI\n",
+       "run_id                                          \n",
+       "20260923T121716.761-c517       1    2758       3\n",
+       "20260923T121720.173-a13f       1    3062       3\n",
+       "20260923T121723.647-be9d       1    2619       3"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "table = pd.read_csv(LOGFILE + \"_simplification_table\")\n",
+    "print(\"columns:\", list(table.columns))\n",
+    "table.groupby([\"run_id\", \"DataType\"]).size().unstack(fill_value=0)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "brush",
+   "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.13.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/pybrush/EstimatorInterface.py b/pybrush/EstimatorInterface.py
index 675584f0a..2df0f82a8 100644
--- a/pybrush/EstimatorInterface.py
+++ b/pybrush/EstimatorInterface.py
@@ -181,7 +181,14 @@ class EstimatorInterface():
         expected.
         If `scorer` is `"balanced_accuracy"`, this setting is ignored
     logfile: str, optional (default: "")
-        If specified, spits statistics into a logfile. "" means don't log.
+        If specified, writes CSV logs of the run. "" means don't log.
+        Files are appended to (every call to `fit` has its own `run_id`):
+        `<logfile>` (one row per generation, including the best expression),
+        `<logfile>_islands.csv` (per-island statistics),
+        `<logfile>_simplifications.csv` (every replacement made by the
+        simplifiers), `<logfile>_runs.jsonl` (seed and parameters of each run)
+        and, with `inexact_simplification`, `<logfile>_simplification_table`.
+        See the "Logging the evolution" guide.
     random_state: int or None, default None
         If int, then the value is used to seed the c++ random generator; if None,
         then a seed will be generated using a non-deterministic generator. A
diff --git a/src/engine.cpp b/src/engine.cpp
index f4e945017..ea023b49d 100644
--- a/src/engine.cpp
+++ b/src/engine.cpp
@@ -3,6 +3,10 @@
 #include <iostream>
 #include <fstream>
 #include <cmath>
+#include <chrono>
+#include <cstdio>
+#include <ctime>
+#include <random>
 
 namespace Brush{
 
@@ -50,89 +54,65 @@ void Engine<T>::print_progress(float percentage)
 
 
 template <ProgramType T>
-void Engine<T>::calculate_stats()
+typename Engine<T>::PopSummary Engine<T>::summarize(const vector<size_t>& indices) const
 {
-    int pop_size = 0;
-    if (params.num_islands < 0) {
-        HANDLE_ERROR_THROW("Invalid params.num_islands: cannot be negative");
-    }
+    const size_t n = indices.size();
 
-    if (static_cast<size_t>(params.num_islands) > pop.island_indexes.size()) {
-        HANDLE_ERROR_THROW(
-            "params.num_islands is greater than pop.island_indexes size in calculate_stats");
-    }
+    ArrayXf scores(n);
+    ArrayXf scores_v(n);
+    ArrayXi sizes(n);
+    ArrayXi complexities(n);
 
-    for (int island=0; island<params.num_islands; ++island)
+    int index = 0; // counter for population size of valid individuals 
+    for (const size_t population_index : indices)
     {
-        auto indices = pop.island_indexes.at(island);
-        pop_size += indices.size();
-    }
+        if (population_index >= this->pop.individuals.size()) {
+            HANDLE_ERROR_THROW(
+                "Invalid population index " + to_string(population_index)
+                + " (individuals size=" + to_string(this->pop.individuals.size()) + ")");
+        }
 
-    ArrayXf scores(pop_size);
-    ArrayXf scores_v(pop_size);
-    
-    // TODO: change all size_t to unsigned?
-    ArrayXi sizes(pop_size);
-    ArrayXi complexities(pop_size); 
+        const auto& p = this->pop.individuals.at(population_index);
+        
+        // Skip nullptr individuals (offspring slots not yet filled)
+        if (!p)
+            continue;
 
-    float error_weight = Individual<T>::weightsMap[params.scorer];
+        float fitness_loss = 0.0f;
+        float fitness_loss_v = 0.0f;
+        unsigned individual_size = 0;
+        unsigned individual_complexity = 0;
 
-    int index = 0;
-    for (int island=0; island<params.num_islands; ++island)
-    {
-        auto indices = pop.island_indexes.at(island);
-        for (unsigned int i=0; i<indices.size(); ++i)
-        {
-            const size_t population_index = indices[i];
-            if (population_index >= this->pop.individuals.size()) {
-                HANDLE_ERROR_THROW(
-                    "Invalid population index in island " + to_string(island)
-                    + ": " + to_string(population_index)
-                    + " (individuals size=" + to_string(this->pop.individuals.size()) + ")");
-            }
+        // If the logger fails, it is easier to catch what have gone wrong
+        try {
+            fitness_loss = p->fitness.get_loss();
+            fitness_loss_v = p->fitness.get_loss_v();
+            individual_size = p->get_size();
+            individual_complexity = p->get_complexity();
 
-            const auto& p = this->pop.individuals.at(population_index);
-            
-            // Skip nullptr individuals (offspring slots not yet filled)
-            if (!p)
-                continue;
+        } catch (const std::exception& e) {
+            HANDLE_ERROR_THROW(
+                "Failed to get fitness/size/complexity from individual at population index "
+                + to_string(population_index) + ": " + e.what());
 
-            float fitness_loss = 0.0f;
-            float fitness_loss_v = 0.0f;
-            unsigned individual_size = 0;
-            unsigned individual_complexity = 0;
-            try {
-                fitness_loss = p->fitness.get_loss();
-                fitness_loss_v = p->fitness.get_loss_v();
-                individual_size = p->get_size();
-                individual_complexity = p->get_complexity();
-            } catch (const std::exception& e) {
-                HANDLE_ERROR_THROW(
-                    "Failed to get fitness/size/complexity from individual at population index "
-                    + to_string(population_index) + ": " + e.what());
-            } catch (...) {
-                HANDLE_ERROR_THROW(
-                    "Failed to get fitness/size/complexity from individual at population index "
-                    + to_string(population_index) + ": unknown error");
-            }
+        } catch (...) {
+            HANDLE_ERROR_THROW(
+                "Failed to get fitness/size/complexity from individual at population index "
+                + to_string(population_index) + ": unknown error");
 
-            if (!std::isfinite(fitness_loss) || !std::isfinite(fitness_loss_v)) {
-                HANDLE_ERROR_THROW(
-                    "Invalid non-finite fitness values at population index "
-                    + to_string(population_index));
-            }
+        }
 
-            // Fitness class will store every information that can be used as
-            // fitness. you just need to access them. Multiplying by weight
-            // so we can find best score. From Fitness::dominates:
-            //     the proper way of comparing weighted values is considering
-            //     everything as a maximization problem
-            scores(index)       = fitness_loss;
-            scores_v(index)     = fitness_loss_v;
-            sizes(index)        = individual_size;
-            complexities(index) = individual_complexity;
-            ++index;
+        if (!std::isfinite(fitness_loss) || !std::isfinite(fitness_loss_v)) {
+            HANDLE_ERROR_THROW(
+                "Invalid non-finite fitness values at population index "
+                + to_string(population_index));
         }
+
+        scores(index)       = fitness_loss;
+        scores_v(index)     = fitness_loss_v;
+        sizes(index)        = individual_size;
+        complexities(index) = individual_complexity;
+        ++index;
     }
 
     // index now contains the actual count of non-null individuals
@@ -142,68 +122,197 @@ void Engine<T>::calculate_stats()
     sizes.conservativeResize(index);
     complexities.conservativeResize(index);
 
+    PopSummary s;
+    s.n_individuals = index;
+    if (index == 0)
+        return s;
+
     // Multiply by weight to make it a maximization problem.
     // Then, multiply again to get rid of signal
-    float    best_score     = index > 0 ? (scores*error_weight).maxCoeff()*error_weight : 0.0f;
-    float    best_score_v   = this->best_ind.fitness.get_loss_v();
+    float error_weight = Individual<T>::weightsMap[params.scorer];
+
+    s.best_score     = (scores*error_weight).maxCoeff()*error_weight;
+    s.best_score_v   = (scores_v*error_weight).maxCoeff()*error_weight;
+    s.med_score      = median(scores);
+    s.med_score_v    = median(scores_v);
+    s.med_size       = median(sizes);
+    s.med_complexity = median(complexities);
+    s.max_size       = sizes.maxCoeff();
+    s.max_complexity = complexities.maxCoeff();
+
+    return s;
+}
+
+template <ProgramType T>
+void Engine<T>::calculate_stats()
+{
+    if (params.num_islands < 0) {
+        HANDLE_ERROR_THROW("Invalid params.num_islands: cannot be negative");
+    }
+    if (static_cast<size_t>(params.num_islands) > pop.island_indexes.size()) {
+        HANDLE_ERROR_THROW(
+            "params.num_islands is greater than pop.island_indexes size in calculate_stats");
+    }
+
+    vector<size_t> indices;
+    for (int island=0; island<params.num_islands; ++island)
+    {
+        const auto& island_indices = pop.island_indexes.at(island);
+        indices.insert(indices.end(), island_indices.begin(), island_indices.end());
+    }
+
+    PopSummary s = summarize(indices);
+
+    // the best validation score is the one of the best individual, which is
+    // not necessarily the smallest validation loss in the population
+    float best_score_v = this->best_ind.fitness.get_loss_v();
 
     if (!std::isfinite(best_score_v)) {
         HANDLE_ERROR_THROW("Invalid non-finite validation loss in best_ind while calculating stats");
     }
     
-    float    med_score      = index > 0 ? median(scores) : 0.0f; 
-    float    med_score_v    = index > 0 ? median(scores_v) : 0.0f; 
-    unsigned med_size       = index > 0 ? median(sizes) : 0;                        
-    unsigned med_complexity = index > 0 ? median(complexities) : 0;
-    unsigned max_size       = index > 0 ? sizes.maxCoeff() : 0;
-    unsigned max_complexity = index > 0 ? complexities.maxCoeff() : 0;
-    
     // update stats
     stats.update(params.current_gen,
                  timer.Elapsed().count(),
-                 best_score,
+                 s.best_score,
                  best_score_v,
-                 med_score,
-                 med_score_v,
-                 med_size,
-                 med_complexity,
-                 max_size,
-                 max_complexity);
+                 s.med_score,
+                 s.med_score_v,
+                 s.med_size,
+                 s.med_complexity,
+                 s.max_size,
+                 s.max_complexity);
 }
 
+namespace {
+    /// unique, human readable identifier for a run. It does not use Brush's
+    /// random generator, so logging never changes the results of a seeded run.
+    string make_run_id()
+    {
+        auto now = std::chrono::system_clock::now();
+        std::time_t t = std::chrono::system_clock::to_time_t(now);
+        auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+            now.time_since_epoch()).count() % 1000;
+
+        std::tm tm{};
+        localtime_r(&t, &tm);
+
+        std::random_device rd;
+        char buf[48];
+        std::snprintf(buf, sizeof(buf), "%04d%02d%02dT%02d%02d%02d.%03d-%04x",
+            tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+            tm.tm_hour, tm.tm_min, tm.tm_sec, static_cast<int>(ms),
+            static_cast<unsigned>(rd() & 0xffff));
+        return buf;
+    }
+}
 
 template <ProgramType T>
-void Engine<T>::log_stats(std::ofstream& log)
+void Engine<T>::open_logs()
 {
-    // print stats in tabular format
-    string sep = ",";
-    if (params.current_gen == 0) // print header
+    run_id = make_run_id();
+
+    // run metadata: one json object per line, one line per call to fit
     {
-        log << "generation"     << sep
-            << "time"           << sep
-            << "best_score"     << sep 
-            << "best_score_val" << sep 
-            << "med_score"      << sep 
-            << "med_score_val"  << sep 
-            << "med_size"       << sep 
-            << "med_complexity" << sep 
-            << "max_size"       << sep 
-            << "max_complexity" << "\n";
+        std::ofstream runs(params.logfile + "_runs.jsonl", std::ofstream::app);
+        if (!runs.is_open())
+            HANDLE_ERROR_THROW("Failed to open logfile: " + params.logfile + "_runs.jsonl");
+
+        json j;
+        j["run_id"] = run_id;
+        j["random_state"] = params.random_state;
+        j["params"] = params;
+        runs << j.dump() << "\n";
     }
-    log << params.current_gen          << sep
-        << timer.Elapsed().count()     << sep
-        << stats.best_score.back()     << sep
-        << stats.best_score_v.back()   << sep
-        << stats.med_score.back()      << sep
-        << stats.med_score_v.back()    << sep
-        << stats.med_size.back()       << sep
-        << stats.med_complexity.back() << sep
-        << stats.max_size.back()       << sep
-        << stats.max_complexity.back() << "\n"; 
+
+    log_generations.open(params.logfile, {
+        "run_id", "random_state", "generation", "time",
+        "best_score", "best_score_val", "med_score", "med_score_val",
+        "med_size", "med_complexity", "max_size", "max_complexity",
+        "best_size", "best_complexity",
+        "stall_count", "archive_size", "n_evaluations",
+        "best_model"});
+
+    log_islands.open(params.logfile + "_islands.csv", {
+        "run_id", "generation", "island", "n_individuals",
+        "best_score", "best_score_val", "med_score", "med_score_val",
+        "med_size", "med_complexity", "max_size", "max_complexity"});
+
+    log_simplifications.open(params.logfile + "_simplifications.csv", {
+        "run_id", "generation", "individual_id", "simplifier", "ret_type",
+        "original", "replacement", "distance"});
+}
+
+template <ProgramType T>
+void Engine<T>::log_stats(unsigned stall_count, const SimplificationRecords& simplifications)
+{
+    using F = Util::CsvWriter;
+
+    log_generations.write_row({
+        run_id,
+        F::field(params.random_state),
+        F::field(params.current_gen),
+        F::field(timer.Elapsed().count()),
+        F::field(stats.best_score.back()),
+        F::field(stats.best_score_v.back()),
+        F::field(stats.med_score.back()),
+        F::field(stats.med_score_v.back()),
+        F::field(stats.med_size.back()),
+        F::field(stats.med_complexity.back()),
+        F::field(stats.max_size.back()),
+        F::field(stats.max_complexity.back()),
+        F::field(best_ind.get_size()),
+        F::field(best_ind.get_complexity()),
+        F::field(stall_count),
+        F::field(archive.individuals.size()),
+        F::field(evaluator.n_evaluations),
+        best_ind.program.get_model()
+    });
+
+    for (int island = 0; island < params.num_islands; ++island)
+    {
+        PopSummary s = summarize(pop.get_island_indexes(island));
+        log_islands.write_row({
+            run_id,
+            F::field(params.current_gen),
+            F::field(island),
+            F::field(s.n_individuals),
+            F::field(s.best_score),
+            F::field(s.best_score_v),
+            F::field(s.med_score),
+            F::field(s.med_score_v),
+            F::field(s.med_size),
+            F::field(s.med_complexity),
+            F::field(s.max_size),
+            F::field(s.max_complexity)
+        });
+    }
+
+    for (const auto& rec : simplifications)
+    {
+        log_simplifications.write_row({
+            run_id,
+            F::field(rec.generation),
+            F::field(rec.individual_id),
+            rec.simplifier,
+            rec.ret_type,
+            rec.original,
+            rec.replacement,
+            F::field(rec.distance)
+        });
+    }
+}
+
+template <ProgramType T>
+void Engine<T>::close_logs()
+{
+    log_generations.close();
+    log_islands.close();
+    log_simplifications.close();
 }
 
 template <ProgramType T>
-void Engine<T>::print_stats(std::ofstream& log, float fraction)
+void Engine<T>::print_stats(float fraction)
 {
     // progress bar
     string bar, space = "";                                 
@@ -455,14 +564,8 @@ void Engine<T>::run(Dataset &data)
     // TODO: make variator have a default constructor and make it an attribute of engine
     Variation<T> variator = Variation<T>(this->params, this->ss, data);
     
-    // log file stream
-    std::ofstream log;
-    if (!params.logfile.empty()) {
-        log.open(params.logfile, std::ofstream::app);
-        if (!log.is_open()) {
-            HANDLE_ERROR_THROW("Failed to open logfile: " + params.logfile);
-        }
-    }
+    if (!params.logfile.empty())
+        open_logs();
 
     evaluator.set_scorer(params.scorer);
 
@@ -542,6 +645,9 @@ void Engine<T>::run(Dataset &data)
         [&](tf::Subflow& subflow) { // loop body (evolutionary main loop)
             auto prepare_gen = subflow.emplace([&]() { 
                 params.set_current_gen(generation);
+                // the variator keeps its own copy of the parameters. It uses the
+                // generation to set individual ids and to tag simplification logs.
+                variator.parameters.set_current_gen(generation);
                 batch = data.get_batch(); // will return the original dataset if it is set to dont use batch 
             }).name("prepare generation");// set generation in params, get batch
 
@@ -621,17 +727,17 @@ void Engine<T>::run(Dataset &data)
                 }
 
                 if(params.verbosity>1)
-                    print_stats(log, fraction);
+                    print_stats(fraction);
                 else if(params.verbosity == 1)
                     print_progress(fraction);
 
-                if (!params.logfile.empty() && log.is_open())
-                    log_stats(log);
-                    
                 if (generation == 0 || updated_best )
                     stall_count = 0;
                 else
                     ++stall_count;
+
+                if (!params.logfile.empty())
+                    log_stats(stall_count, variator.pop_simplification_records());
                 
                 ++generation;
 
@@ -659,18 +765,16 @@ void Engine<T>::run(Dataset &data)
 
             set_is_fitted(true);
             
-            // logging the simplifications performed
+            // dump the expressions stored by the inexact simplifier
             if (!params.logfile.empty() && params.inexact_simplification) {
-                std::ofstream log_simplification;
-                log_simplification.open(params.logfile+"_simplification_table", std::ofstream::app);
-                variator.log_simplification_table(log_simplification);
-                
-                log_simplification.close();
+                Util::CsvWriter log_simplification_table(
+                    params.logfile+"_simplification_table",
+                    Inexact_simplifier::simplification_table_header);
+                variator.log_simplification_table(log_simplification_table, run_id);
             }
 
-            // TODO: open, write, close? (to avoid breaking the file and allow some debugging if things dont work well)
-            if (log.is_open())
-                log.close();
+            if (!params.logfile.empty())
+                close_logs();
 
             // getting the updated versions
             this->ss = variator.search_space;
diff --git a/src/engine.h b/src/engine.h
index b73a60fb8..ec3a34d91 100644
--- a/src/engine.h
+++ b/src/engine.h
@@ -14,6 +14,7 @@ license: GNU/GPL v3
 #include "pop/population.h"
 #include "pop/archive.h"
 #include "selection/selection.h"
+#include "util/csv.h"
 
 #include "taskflow/taskflow.hpp"
 #include <taskflow/algorithm/for_each.hpp>
@@ -61,8 +62,7 @@ class Engine{
     // outputs a progress bar, filled according to @param percentage.
     void print_progress(float percentage);
     void calculate_stats();
-    void print_stats(std::ofstream& log, float fraction);      
-    void log_stats(std::ofstream& log);
+    void print_stats(float fraction);
 
     // all hyperparameters are controlled by the parameter class. please refer to that to change something
     inline Parameters& get_params(){return params;}
@@ -147,6 +147,30 @@ class Engine{
 
     Timer timer; ///< start time of training
 
+    /// summary statistics of a subset of the population (e.g. an island)
+    struct PopSummary {
+        unsigned n_individuals  = 0;
+        float    best_score     = 0.0f; ///< best train loss
+        float    best_score_v   = 0.0f; ///< best validation loss (may be another individual)
+        float    med_score      = 0.0f;
+        float    med_score_v    = 0.0f;
+        unsigned med_size       = 0;
+        unsigned med_complexity = 0;
+        unsigned max_size       = 0;
+        unsigned max_complexity = 0;
+    };
+    PopSummary summarize(const vector<size_t>& indices) const;
+
+    // run logs, written when params.logfile is set
+    string run_id;                          ///< identifies the rows of one call to fit
+    Util::CsvWriter log_generations;        ///< <logfile>
+    Util::CsvWriter log_islands;            ///< <logfile>_islands.csv
+    Util::CsvWriter log_simplifications;    ///< <logfile>_simplifications.csv
+
+    void open_logs();
+    void log_stats(unsigned stall_count, const SimplificationRecords& simplifications);
+    void close_logs();
+
     void init();
 
     /// set flag indicating whether fit has been called
diff --git a/src/eval/evaluation.cpp b/src/eval/evaluation.cpp
index b3bfdadf6..766731638 100644
--- a/src/eval/evaluation.cpp
+++ b/src/eval/evaluation.cpp
@@ -55,6 +55,8 @@ template<ProgramType T>
 void Evaluation<T>::assign_fit(Individual<T>& ind, const Dataset& data, 
                                const Parameters& params, bool val)
 {
+    ++n_evaluations;
+
     VectorXf errors;
     using PT = ProgramType;
     
diff --git a/src/eval/evaluation.h b/src/eval/evaluation.h
index 2c9889181..51a785bd3 100644
--- a/src/eval/evaluation.h
+++ b/src/eval/evaluation.h
@@ -87,6 +87,10 @@ class Evaluation {
     void assign_fit(Individual<T>& ind, const Dataset& data,
                     const Parameters& params, bool val=false);
 
+    /// number of calls to assign_fit (each one scores an individual on the
+    /// training partition and, if there is one, on the validation partition).
+    size_t n_evaluations = 0;
+
     // representation program (TODO: implement)
 };
 
diff --git a/src/simplification/constants.h b/src/simplification/constants.h
index f58777e96..835608d34 100644
--- a/src/simplification/constants.h
+++ b/src/simplification/constants.h
@@ -6,6 +6,7 @@
 #include "../program/program.h"
 #include "../vary/search_space.h"
 #include "../util/utils.h"
+#include "record.h"
 
 using namespace std;
 using Brush::Node;
@@ -15,9 +16,11 @@ namespace Brush { namespace Simpl{
     class Constants_simplifier
     {
         public:
+            /// @param records if not null, every replacement is appended to it
             template <ProgramType P>
             Program<P> simplify_tree(
-                Program<P>& program, const SearchSpace &ss, const Dataset &d)
+                Program<P>& program, const SearchSpace &ss, const Dataset &d,
+                SimplificationRecords* records = nullptr)
             {
                 using RetType =
                 typename std::conditional_t<P == PT::Regressor, ArrayXf,
@@ -80,8 +83,18 @@ namespace Brush { namespace Simpl{
                                 ss.terminal_map.at(n.ret_type).size()-1);
 
                             cte.W = branch_pred.mean();
+
+                            string original;
+                            if (records)
+                                original = spot.node->get_model();
+
                             simplified_program.Tree.erase_children(spot); 
                             spot = simplified_program.Tree.replace(spot, cte);
+
+                            if (records)
+                                records->push_back({0, 0, "constants",
+                                                    DataTypeName.at(n.ret_type),
+                                                    original, spot.node->get_model(), 0.0f});
                         }
                     }
                     ++spot;
diff --git a/src/simplification/inexact.h b/src/simplification/inexact.h
index 99c825931..7623f51ab 100644
--- a/src/simplification/inexact.h
+++ b/src/simplification/inexact.h
@@ -6,6 +6,8 @@
 #include "../program/program.h"
 #include "../vary/search_space.h"
 #include "../util/utils.h"
+#include "../util/csv.h"
+#include "record.h"
 
 using namespace std;
 using Brush::Node;
@@ -98,18 +100,19 @@ class HashStorage {
         return result;
     }
 
-    void print(const string& prefix, std::ofstream& log) const {
+    /// writes one row per stored tree: prefix..., plane, key, tree
+    void print(const vector<string>& prefix, Util::CsvWriter& log) const {
         for (size_t plane_idx = 0; plane_idx < storage.size(); ++plane_idx) {
             for (const auto& kv : storage[plane_idx]) {
                 size_t key = kv.first;
                 const auto& trees = kv.second;
 
                 for (const auto& t : trees) {
-                    log << prefix
-                              << plane_idx << ","
-                              << key << ","
-                              << t.begin().node->get_model()
-                              << "\n";
+                    vector<string> row(prefix);
+                    row.push_back(std::to_string(plane_idx));
+                    row.push_back(std::to_string(key));
+                    row.push_back(t.begin().node->get_model());
+                    log.write_row(row);
                 }
             }
         }
@@ -157,9 +160,11 @@ class Inexact_simplifier
             }  
         }
 
+        /// @param records if not null, every replacement is appended to it
         template<ProgramType P>
         Program<P> simplify_tree(Program<P>& program,
-                                    const SearchSpace &ss, const Dataset &d)
+                                    const SearchSpace &ss, const Dataset &d,
+                                    SimplificationRecords* records = nullptr)
         {
             // using RetType =
             //     typename // std::conditional_t<P == PT::Regressor, ArrayXf,
@@ -229,14 +234,22 @@ class Inexact_simplifier
                             }
                             if (best_distance < threshold) {
 
-                                // cout << "replacing " << spot.node->get_model();
+                                string original;
+                                if (records)
+                                    original = spot.node->get_model();
+
                                 simplified_program.Tree.erase_children(spot);
 
                                 const tree<Node> best_branch_copy(best_branch);
-                                // cout << " with " << best_branch_copy.begin().node->get_model() << endl;
                                 
                                 spot = simplified_program.Tree.move_ontop(spot, best_branch_copy.begin());
 
+                                if (records)
+                                    records->push_back({0, 0, "inexact",
+                                                        dt_to_string(spot.node->data.ret_type),
+                                                        original, spot.node->get_model(),
+                                                        best_distance});
+
                                 // learning the simplifications made here
                                 analyze_tree(simplified_program, ss, d);
                             }
@@ -273,17 +286,17 @@ class Inexact_simplifier
         }
 
         // wrapper to print all equivalentExpressions
-        inline void log_simplification_table(std::ofstream& log) {
-            // print header
-            log << "DataType,Plane,Key,Tree\n";
+        inline static const vector<string> simplification_table_header = {
+            "run_id", "DataType", "Plane", "Key", "Tree"};
 
+        /// dumps every stored expression. Expects a writer opened with
+        /// simplification_table_header.
+        inline void log_simplification_table(Util::CsvWriter& log, const string& run_id) {
             for (const auto& kv : equivalentExpressions) {
                 DataType dt = kv.first;
                 const HashStorage& hs = kv.second;
 
-                // prefix is the DataType name + a comma
-                std::string prefix = dt_to_string(dt) + ",";
-                hs.print(prefix, log);
+                hs.print({run_id, dt_to_string(dt)}, log);
             }
         }
 
diff --git a/src/simplification/record.h b/src/simplification/record.h
new file mode 100644
index 000000000..48963c6dc
--- /dev/null
+++ b/src/simplification/record.h
@@ -0,0 +1,27 @@
+#ifndef SIMPLIFICATION_RECORD_H
+#define SIMPLIFICATION_RECORD_H
+
+#include <string>
+#include <vector>
+
+namespace Brush { namespace Simpl{
+
+/// One replacement performed by a simplifier, as written to
+/// `<logfile>_simplifications.csv`.
+struct SimplificationRecord
+{
+    unsigned    generation    = 0;
+    unsigned    individual_id = 0;
+    std::string simplifier;  ///< "constants" or "inexact"
+    std::string ret_type;    ///< return type of the replaced subtree
+    std::string original;    ///< subtree before the replacement
+    std::string replacement; ///< subtree after the replacement
+    float       distance = 0.0f; ///< mse between program predictions before/after (inexact only)
+};
+
+using SimplificationRecords = std::vector<SimplificationRecord>;
+
+} // Simpl
+} // Brush
+
+#endif
diff --git a/src/util/csv.h b/src/util/csv.h
new file mode 100644
index 000000000..7f5797fef
--- /dev/null
+++ b/src/util/csv.h
@@ -0,0 +1,153 @@
+/* Brush
+copyright 2026 William La Cava
+license: GNU/GPL v3
+*/
+
+#ifndef CSV_H
+#define CSV_H
+
+#include <cstdio>
+#include <fstream>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include "error.h"
+
+namespace Brush { namespace Util {
+
+/*!
+ * @class CsvWriter
+ * @brief Minimal RFC 4180 CSV writer used by the run logs.
+ *
+ * - Fields containing a separator, a quote or a line break are quoted, and
+ *   inner quotes are doubled, so expressions such as `Pow(x0,x1)` are safe.
+ * - Files are opened in append mode. The header is written only when the file
+ *   is new or empty; appending to a file whose header differs throws, instead
+ *   of silently mixing two schemas in the same file.
+ * - Every row is flushed, so logs are usable while (or after a crash during)
+ *   a run.
+ */
+class CsvWriter
+{
+public:
+    CsvWriter() = default;
+
+    CsvWriter(const std::string& path, const std::vector<std::string>& header)
+    {
+        open(path, header);
+    }
+
+    void open(const std::string& path, const std::vector<std::string>& header)
+    {
+        close();
+
+        n_columns = header.size();
+        const std::string header_line = format_row(header);
+
+        std::string existing;
+        {
+            std::ifstream in(path);
+            if (in.is_open())
+                std::getline(in, existing);
+        }
+
+        if (!existing.empty() && existing != header_line)
+            HANDLE_ERROR_THROW(
+                "Log file '" + path + "' already exists with different columns.\n"
+                "  expected: " + header_line + "\n"
+                "  found   : " + existing + "\n"
+                "Use a different logfile or remove the old one.");
+
+        out = std::make_shared<std::ofstream>(path, std::ofstream::app);
+        if (!out->is_open())
+            HANDLE_ERROR_THROW("Failed to open log file: " + path);
+
+        if (existing.empty())
+            *out << header_line << '\n' << std::flush;
+    }
+
+    bool is_open() const { return out && out->is_open(); }
+
+    void close()
+    {
+        if (is_open())
+            out->close();
+        out.reset();
+    }
+
+    void write_row(const std::vector<std::string>& fields)
+    {
+        if (!is_open())
+            HANDLE_ERROR_THROW("CsvWriter: writing to a closed file");
+
+        if (fields.size() != n_columns)
+            HANDLE_ERROR_THROW(
+                "CsvWriter: row has " + std::to_string(fields.size())
+                + " fields, header has " + std::to_string(n_columns));
+
+        *out << format_row(fields) << '\n' << std::flush;
+    }
+
+    /// quotes a field if it contains a separator, a quote or a line break
+    static std::string escape(const std::string& field)
+    {
+        if (field.find_first_of(",\"\n\r") == std::string::npos)
+            return field;
+
+        std::string quoted = "\"";
+        for (char c : field)
+        {
+            if (c == '"')
+                quoted += '"';
+            quoted += c;
+        }
+        quoted += '"';
+        return quoted;
+    }
+
+    /// converts a value to a field. Floats use enough digits to round-trip.
+    template <typename V>
+    static std::string field(const V& value)
+    {
+        if constexpr (std::is_same_v<V, bool>)
+            return value ? "1" : "0";
+        else if constexpr (std::is_floating_point_v<V>)
+        {
+            char buf[32];
+            std::snprintf(buf, sizeof(buf), "%.9g", static_cast<double>(value));
+            return buf;
+        }
+        else if constexpr (std::is_arithmetic_v<V>)
+            return std::to_string(value);
+        else
+        {
+            std::ostringstream ss;
+            ss << value;
+            return ss.str();
+        }
+    }
+
+private:
+    static std::string format_row(const std::vector<std::string>& fields)
+    {
+        std::string line;
+        for (size_t i = 0; i < fields.size(); ++i)
+        {
+            if (i > 0)
+                line += ',';
+            line += escape(fields[i]);
+        }
+        return line;
+    }
+
+    // shared so that the owner (e.g. Engine) stays copyable
+    std::shared_ptr<std::ofstream> out;
+    size_t n_columns = 0;
+};
+
+} } // Util, Brush
+
+#endif
diff --git a/src/util/logger.h b/src/util/logger.h
index ae04c7944..9f8c93ed0 100644
--- a/src/util/logger.h
+++ b/src/util/logger.h
@@ -6,8 +6,8 @@ license: GNU/GPL v3
 #ifndef LOGGER_H
 #define LOGGER_H
 
-#include<iostream>
-using namespace std;
+#include <iostream>
+#include <string>
 
 namespace Brush {
 namespace Util{
@@ -50,10 +50,10 @@ class Logger
         * @param sep The separator to be used between log messages.
         * @return The formatted log message.
         */
-    string log(string m, int v, string sep="\n") const;
+    std::string log(std::string m, int v, std::string sep="\n") const;
     
 private:
-    int verbosity; //!< The current log level.
+    int verbosity = 0; //!< The current log level (matches Parameters::verbosity default).
     static Logger* instance; //!< The singleton instance of the logger.
 };
 
diff --git a/src/vary/variation.h b/src/vary/variation.h
index 4917fdcf6..7b5296533 100644
--- a/src/vary/variation.h
+++ b/src/vary/variation.h
@@ -348,9 +348,13 @@ class Variation {
             // simplify before calculating fitness (order matters, as they are not refitted and constants simplifier does not replace with the right value.)
             // simplify constants first to avoid letting the lsh simplifier to visit redundant branches
             
+            // replacements are only recorded when they are going to be logged
+            SimplificationRecords records;
+            SimplificationRecords* records_ptr = parameters.logfile.empty() ? nullptr : &records;
+
             if (parameters.constants_simplification && do_simplification)
             {
-                constants_simplifier.simplify_tree<T>(ind.program, search_space, data.get_training_data());  
+                constants_simplifier.simplify_tree<T>(ind.program, search_space, data.get_training_data(), records_ptr);  
             }
 
             if (parameters.inexact_simplification)
@@ -363,18 +367,20 @@ class Variation {
 
                 if (do_simplification)
                 {
-                    // string prg_str = ind.program.get_model();
-
-                    inexact_simplifier.simplify_tree<T>(ind.program, search_space, data_simp);
-
-                    // if (ind.program.get_model().compare(prg_str)!= 0)
-                    //     cout << prg_str << endl << ind.program.get_model() << endl << "=====" << endl;
+                    inexact_simplifier.simplify_tree<T>(ind.program, search_space, data_simp, records_ptr);
                 }
                 else
                 {
                     inexact_simplifier.analyze_tree<T>(ind.program, search_space, data_simp);
                 }
             }
+
+            for (auto& rec : records)
+            {
+                rec.generation    = parameters.current_gen;
+                rec.individual_id = id;
+                simplification_records.push_back(std::move(rec));
+            }
         
             evaluator.assign_fit(ind, data, parameters, false);
             
@@ -606,8 +612,16 @@ class Variation {
         return std::nullopt;
     };
 
-    inline void log_simplification_table(std::ofstream& log) {
-        inexact_simplifier.log_simplification_table(log);
+    inline void log_simplification_table(Util::CsvWriter& log, const string& run_id) {
+        inexact_simplifier.log_simplification_table(log, run_id);
+    };
+
+    /// returns the simplifications performed since the last call, and clears them.
+    /// Records are only collected when `parameters.logfile` is set.
+    inline SimplificationRecords pop_simplification_records() {
+        SimplificationRecords out;
+        out.swap(simplification_records);
+        return out;
     };
 
     // bandit_sample_subtree // TODO: should I implement this? (its going to be hard).
@@ -630,6 +644,7 @@ class Variation {
     // simplification methods
     Constants_simplifier constants_simplifier; 
     Inexact_simplifier inexact_simplifier;
+    SimplificationRecords simplification_records; ///< replacements not yet logged
 };
 
 class MutationBase {    
diff --git a/tests/cpp/test_brush.cpp b/tests/cpp/test_brush.cpp
index 7e9af49a4..06bec6af0 100644
--- a/tests/cpp/test_brush.cpp
+++ b/tests/cpp/test_brush.cpp
@@ -5,6 +5,7 @@
 
 // #include "../../src/program/dispatch_table.h"
 #include "../../src/data/io.h"
+#include <fstream>
 #include "../../src/engine.h"
 #include "../../src/selection/selection.h"
 #include "../../src/selection/selection_operator.h"
@@ -88,12 +89,36 @@ TEST(Engine, EngineWorks)
     est6.run(data);
     
     std::cout << "n jobs = 2" << std::endl;
-    params.set_logfile("./tests/cpp/__logfile.csv"); // TODO: test classification and regression and save log so we can inspect it
+
+    // start from clean log files: appending to a log written by an older
+    // version (different columns) is an error. we start by cleaning up previous files
+    const string logfile = "./tests/cpp/__logfile.csv";
+    const vector<string> log_suffixes = {"", "_islands.csv", "_simplifications.csv",
+                                         "_runs.jsonl", "_simplification_table"};
+    for (const auto& suffix : log_suffixes)
+        std::remove((logfile + suffix).c_str());
+
+    params.set_logfile(logfile);
     params.set_n_jobs(2);
     Brush::RegressorEngine est7(params, ss);
     est7.run(data);
     params.set_logfile("");
 
+    // one header plus one row per generation
+    {
+        std::ifstream in(logfile);
+        ASSERT_TRUE(in.is_open());
+        string line;
+        std::getline(in, line);
+        ASSERT_EQ(line.rfind("run_id,random_state,generation,", 0), 0);
+        size_t rows = 0;
+        while (std::getline(in, line))
+            ++rows;
+        ASSERT_EQ(rows, params.get_max_gens());
+    }
+    for (const auto& suffix : {"_islands.csv", "_simplifications.csv", "_runs.jsonl"})
+        ASSERT_TRUE(std::ifstream(logfile + suffix).is_open()) << logfile + suffix;
+
     std::cout << "n jobs = -1" << std::endl;
     params.set_n_jobs(-1);
     Brush::RegressorEngine est8(params, ss);
diff --git a/tests/cpp/test_logging.cpp b/tests/cpp/test_logging.cpp
new file mode 100644
index 000000000..aa8ae61fa
--- /dev/null
+++ b/tests/cpp/test_logging.cpp
@@ -0,0 +1,63 @@
+#include "testsHeader.h"
+#include "../../src/util/csv.h"
+
+#include <cstdio>
+#include <fstream>
+
+using Brush::Util::CsvWriter;
+
+namespace {
+    vector<string> read_lines(const string& path)
+    {
+        std::ifstream in(path);
+        vector<string> lines;
+        for (string line; std::getline(in, line); )
+            lines.push_back(line);
+        return lines;
+    }
+}
+
+TEST(Logging, CsvEscape)
+{
+    ASSERT_EQ(CsvWriter::escape("x0"), "x0");
+    ASSERT_EQ(CsvWriter::escape("Pow(x0,x1)"), "\"Pow(x0,x1)\"");
+    ASSERT_EQ(CsvWriter::escape("a\"b"), "\"a\"\"b\"");
+    ASSERT_EQ(CsvWriter::escape("a\nb"), "\"a\nb\"");
+    ASSERT_EQ(CsvWriter::escape(""), "");
+}
+
+TEST(Logging, CsvField)
+{
+    ASSERT_EQ(CsvWriter::field(3), "3");
+    ASSERT_EQ(CsvWriter::field(true), "1");
+    ASSERT_EQ(CsvWriter::field(0.1f), "0.100000001");  // round-trips float precision
+    ASSERT_EQ(CsvWriter::field(string("abc")), "abc");
+}
+
+TEST(Logging, CsvWriterHeaderOnceAndQuoting)
+{
+    const string path = "./tests/cpp/__test_csv_writer.csv";
+    std::remove(path.c_str());
+
+    {
+        CsvWriter w(path, {"id", "model"});
+        w.write_row({"1", "Add(x0,x1)"});
+    }
+    {
+        // appending with the same header must not repeat it
+        CsvWriter w(path, {"id", "model"});
+        w.write_row({"2", "x0"});
+        ASSERT_THROW(w.write_row({"too", "many", "fields"}), std::runtime_error);
+    }
+
+    auto lines = read_lines(path);
+    ASSERT_EQ(lines.size(), 3);
+    ASSERT_EQ(lines[0], "id,model");
+    ASSERT_EQ(lines[1], "1,\"Add(x0,x1)\"");
+    ASSERT_EQ(lines[2], "2,x0");
+
+    // a different schema must not be mixed into the same file
+    ASSERT_THROW(CsvWriter(path, {"id", "other"}), std::runtime_error);
+
+    std::remove(path.c_str());
+}
diff --git a/tests/python/test_sklearn_interface.py b/tests/python/test_sklearn_interface.py
index 7abf0aa0a..faa18b569 100644
--- a/tests/python/test_sklearn_interface.py
+++ b/tests/python/test_sklearn_interface.py
@@ -107,19 +107,78 @@ def test_brush_logfile_output(tmp_path):
 
     logfile = tmp_path / "brush_run.log"
 
-    BrushRegressor(
-        inexact_simplification=True,
-        max_gens=5,
-        pop_size=10,
-        logfile=str(logfile),
-        verbosity=0,
-    ).fit(X, y)
+    def fit():
+        BrushRegressor(
+            functions=["Add", "Sub", "Mul", "Div", "Pow", "Sin", "Cos"],
+            inexact_simplification=True,
+            max_gens=5,
+            pop_size=10,
+            num_islands=2,
+            logfile=str(logfile),
+            verbosity=0,
+        ).fit(X, y)
+
+    # We will train two different instances with same logfile. This is 
+    # designed to make partial_fits to also write on the same file (but with a 
+    # different run)
+    fit()
+    fit()  # appending a second run must keep every file parseable
+
+    gens = pd.read_csv(logfile)
+    assert list(gens.columns) == [
+        "run_id", "random_state", "generation", "time",
+        "best_score", "best_score_val", "med_score", "med_score_val",
+        "med_size", "med_complexity", "max_size", "max_complexity",
+        "best_size", "best_complexity",
+        "stall_count", "archive_size", "n_evaluations",
+        "best_model",
+    ]
+    assert gens["run_id"].nunique() == 2
+    assert (gens.groupby("run_id").size() == 5).all()
+    assert gens["best_model"].notna().all()
+    for _, run in gens.groupby("run_id"):
+        assert run["n_evaluations"].is_monotonic_increasing
+        assert list(run["generation"]) == list(range(5))
+
+    islands = pd.read_csv(str(logfile) + "_islands.csv")
+    assert len(islands) == 2 * 5 * 2  # runs * generations * islands
+    assert set(islands["island"]) == {0, 1}
+
+    simplifications = pd.read_csv(str(logfile) + "_simplifications.csv")
+    assert list(simplifications.columns) == [
+        "run_id", "generation", "individual_id", "simplifier", "ret_type",
+        "original", "replacement", "distance",
+    ]
+    assert set(simplifications["simplifier"]) <= {"constants", "inexact"}
 
-    assert logfile.exists()
-    assert logfile.stat().st_size > 0
+    table = pd.read_csv(str(logfile) + "_simplification_table")
+    assert list(table.columns) == ["run_id", "DataType", "Plane", "Key", "Tree"]
+    assert table["run_id"].nunique() == 2
+
+    runs = pd.read_json(str(logfile) + "_runs.jsonl", lines=True)
+    assert len(runs) == 2
+    assert set(runs["run_id"]) == set(gens["run_id"])
+    assert runs["params"].iloc[0]["logfile"] == str(logfile)
+
+
+def test_brush_logfile_same_seed_same_best_models(tmp_path):
+    X, y = make_regression(n_samples=80, n_features=3, noise=0.1, random_state=42)
 
-    simplification_log = tmp_path / "brush_run.log_simplification_table"
-    assert simplification_log.exists()
+    def best_models(logfile):
+        BrushRegressor(
+            max_gens=10,
+            pop_size=20,
+            num_islands=2,
+            logfile=str(logfile),
+            random_state=123,
+        ).fit(X, y)
+        return pd.read_csv(logfile)["best_model"]
+
+    first = best_models(tmp_path / "run_a.csv")
+    second = best_models(tmp_path / "run_b.csv")
+
+    assert len(first) == 10
+    pd.testing.assert_series_equal(first, second)
 
 
 def test_brush_classifier_population_reuse(tmp_path):