{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "73a6860d",
   "metadata": {},
   "source": [
    "# `sumo-marouter` — SUMO's macroscopic assignment as an external-simulator adapter\n",
    "\n",
    "**What.** `sumo-marouter` wraps `eclipse-sumo`'s macroscopic stochastic\n",
    "user-equilibrium tool `marouter` (Lopez et al. 2018, `[lopez2018microscopic]`,\n",
    "[docs/REFERENCES.md](../../docs/REFERENCES.md)) as a benchmark model: it compiles a\n",
    "fixed-demand, `power==1` (linear-latency) scenario into a real SUMO network, runs\n",
    "`marouter` to convergence under ITS OWN hardcoded cost law, reads the per-edge\n",
    "flows back into repo-native units, and lets the harness certify the equilibrium\n",
    "gap under the scenario's DECLARED BPR costs (P1) — never marouter's own.\n",
    "\n",
    "**Why it is in the benchmark.** It is the first EXTERNAL simulator on the\n",
    "benchmark and the first row on the accuracy-vs-certificate ladder to ask a\n",
    "production tool to solve the repo's own equilibrium: marouter's cost law is a\n",
    "*hardcoded* linear-in-flow class function (PTV-Validate / VISUM-Cologne, not the\n",
    "ITSC paper), so the adapter's job is a **compile map** — translating the\n",
    "scenario's BPR coefficients into SUMO edge geometry (length, lane count) that\n",
    "reproduces the SAME cost law to machine precision on every REPRESENTABLE link.\n",
    "Three representability floors are unavoidable (a forced eps-intercept on\n",
    "zero-intercept links, a parasitic slope on zero-slope links, integer lane\n",
    "quantization) — refused loudly when they cannot be met, never silently clamped.\n",
    "See the [model compendium](../../docs/MODELS.md) and\n",
    "[docs/design/adr-027-sumo-marouter.md](../../docs/design/adr-027-sumo-marouter.md)\n",
    "(P1, the compile-map derivation and every measured anchor).\n",
    "\n",
    "**Scope.** A certified Braess run (the measured mapping floor, A1), the\n",
    "MANDATORY cost-matched anchor separating that floor from solver error (A2 — \"the\n",
    "row is not shipped without A2\"), the asymmetric two-route direction where a\n",
    "converged white-box solver certifies an orders-of-magnitude better gap (A3, the\n",
    "feasibility-is-not-equilibrium-quality headline), and the honest negative\n",
    "control (`assignment_method=\"incremental\"`, NOT an equilibrium) plus the traps\n",
    "this adapter refuses rather than silently mis-scores."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5a67e57",
   "metadata": {},
   "source": [
    "## How this notebook is graded\n",
    "\n",
    "**A notebook never claims a number it does not compute in that cell.** Every\n",
    "scored quantity below is recomputed live by the P1 `Evaluator` from the flows\n",
    "`marouter` emitted, in the cell where it is claimed; the adapter's own\n",
    "`--tolerance` (SUE stability under ITS OWN costs) is never the certified gap.\n",
    "`marouter` self-reports NO gap at all (`provides_gap=False`) — the certificate\n",
    "is the only number, and it is the honest simulator-to-benchmark mapping floor,\n",
    "never hidden ([README](../../README.md), *Certified, not self-reported*)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d384ab51",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T13:55:29.754349Z",
     "iopub.status.busy": "2026-07-21T13:55:29.754085Z",
     "iopub.status.idle": "2026-07-21T13:55:31.947560Z",
     "shell.execute_reply": "2026-07-21T13:55:31.946430Z"
    }
   },
   "outputs": [],
   "source": [
    "# Setup. `sumo-marouter` is a GUARDED model behind the optional `eclipse-sumo`\n",
    "# wheel (`pip install tabench[sumo]`) -- the ONLY guard cell in the tutorials so\n",
    "# far. The inline backend is Agg-based (headless CI renders into the notebook);\n",
    "# NEVER matplotlib.use(\"Agg\") in-kernel -- it silently suppresses inline capture.\n",
    "%matplotlib inline\n",
    "try:\n",
    "    import sumo  # noqa: F401  (the eclipse-sumo wheel; absence -> ModuleNotFoundError)\n",
    "except ModuleNotFoundError as exc:\n",
    "    if exc.name != \"sumo\":\n",
    "        raise\n",
    "    raise ModuleNotFoundError(\n",
    "        \"sumo-marouter needs the optional 'sumo' extra: pip install tabench[sumo]\"\n",
    "    ) from exc\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "from tabench import (\n",
    "    BiconjugateFrankWolfeModel,\n",
    "    Budget,\n",
    "    Evaluator,\n",
    "    RngBundle,\n",
    "    Trace,\n",
    "    braess_scenario,\n",
    "    two_route_scenario,\n",
    "    viz,\n",
    ")\n",
    "from tabench.models.adapters import _sumo_io as sio\n",
    "from tabench.models.adapters.sumo_marouter import SumoMarouterModel"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf27c8ca",
   "metadata": {},
   "source": [
    "## The compile-map story (adr-027, Decision 3)\n",
    "\n",
    "`marouter` does not take a user BPR function: its congestion law is *hardcoded*\n",
    "per SUMO road class, linear in flow, `t(f) = t0 (1 + K f/C)`. A repo link with\n",
    "linear latency `t(v) = A + B v` (`power == 1` only) compiles to a SUMO edge\n",
    "whose length/lane-count reproduce `(A, B)` via `t0 = A tau`, `slope = tau B/s`\n",
    "at a flow scale `s` chosen so every REPRESENTABLE link's lane count is an exact\n",
    "integer — matching the repo BPR to machine precision on those links. Zero-\n",
    "intercept and zero-slope links force a small perturbation (an eps-intercept /\n",
    "parasitic slope) that is the honest, MEASURED mapping floor below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a1bbfc05",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T13:55:31.951422Z",
     "iopub.status.busy": "2026-07-21T13:55:31.951011Z",
     "iopub.status.idle": "2026-07-21T13:55:31.956265Z",
     "shell.execute_reply": "2026-07-21T13:55:31.955476Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "scenario      : braess\n",
      "content hash  : cf00f411cdccec88…\n",
      "total demand  : 6.0\n",
      "task          : marouter macroscopic SUE under its own hardcoded linear vdf\n"
     ]
    }
   ],
   "source": [
    "scenario = braess_scenario()  # demand=6.0, the A1 anchor\n",
    "print(f\"scenario      : {scenario.name}\")\n",
    "print(f\"content hash  : {scenario.content_hash()[:16]}…\")\n",
    "print(f\"total demand  : {scenario.demand.total}\")\n",
    "print(\"task          : marouter macroscopic SUE under its own hardcoded linear vdf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "496c4fb0",
   "metadata": {},
   "source": [
    "## Solve\n",
    "\n",
    "The model contract ([CONTRIBUTING.md](../../CONTRIBUTING.md)): a model receives\n",
    "`(scenario, budget, rng, trace)`. `sumo-marouter` maps `iterations ->\n",
    "--max-iterations`; `marouter` exposes no shortest-path count, so `sp_calls`\n",
    "is unmappable and an `sp_calls`-only budget is REFUSED rather than run\n",
    "unbounded. `provides_gap=False`, and the model discloses (never hides) that\n",
    "`marouter` does not report its executed iteration count\n",
    "(`engine_iterations_executed_unknown=1`, provenance)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f5326054",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T13:55:31.959431Z",
     "iopub.status.busy": "2026-07-21T13:55:31.958968Z",
     "iopub.status.idle": "2026-07-21T13:55:32.645738Z",
     "shell.execute_reply": "2026-07-21T13:55:32.644782Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model            : sumo-marouter\n",
      "emitted flows    : [3.998156 2.001844 1.996313 2.001844 3.998156]\n",
      "engine           : Eclipse SUMO marouter 1.27.1  (provenance)\n",
      "engine_iterations_executed_unknown : 1  (disclosed, not hidden)\n"
     ]
    }
   ],
   "source": [
    "model = SumoMarouterModel()  # defaults: assignment_method=\"SUE\", route_choice=\"logit\"\n",
    "bundle = model.solve(scenario, Budget(iterations=50), RngBundle(42), Trace())\n",
    "\n",
    "final = bundle.final\n",
    "print(f\"model            : {model.name}\")\n",
    "print(f\"emitted flows    : {np.round(final.link_flows, 6)}\")\n",
    "print(f\"engine           : {bundle.seed_info.get('engine', 'unknown')}  (provenance)\")\n",
    "print(f\"engine_iterations_executed_unknown : \"\n",
    "      f\"{final.self_report['engine_iterations_executed_unknown']:.0f}  (disclosed, not hidden)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e9816c8",
   "metadata": {},
   "source": [
    "## Certify (P1) — A1, the measured Braess mapping floor\n",
    "\n",
    "The harness scores `marouter`'s Braess flows against the SAME certificate every\n",
    "white-box solver here earns. The certified gap is *real but small* — the\n",
    "measured mapping floor, not solver error (A2, next cell, is what proves that)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "746d9ce0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T13:55:32.649754Z",
     "iopub.status.busy": "2026-07-21T13:55:32.649576Z",
     "iopub.status.idle": "2026-07-21T13:55:32.656510Z",
     "shell.execute_reply": "2026-07-21T13:55:32.655702Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "certified relative gap  : 1.739e-04\n",
      "feasible                : 1\n",
      "node_balance_residual   : 4.44e-16\n",
      "analytic UE flows       : [4. 2. 2. 2. 4.]  (marouter within the mapping-floor perturbation)\n"
     ]
    }
   ],
   "source": [
    "evaluator = Evaluator(scenario)\n",
    "metrics = evaluator.evaluate(final.link_flows)\n",
    "print(f\"certified relative gap  : {metrics['relative_gap']:.3e}\")\n",
    "print(f\"feasible                : {metrics['feasible']:.0f}\")\n",
    "print(f\"node_balance_residual   : {metrics['node_balance_residual']:.2e}\")\n",
    "assert metrics[\"feasible\"] == 1.0\n",
    "assert metrics[\"relative_gap\"] < 3e-4  # loose, version-robust ceiling (measured ~1.74e-4)\n",
    "assert metrics[\"node_balance_residual\"] < 1e-6\n",
    "\n",
    "# Analytic Braess UE anchor, recomputed in-cell: marouter's flows sit within the\n",
    "# measured perturbation floor of the true oracle (4,2,2,2,4), not exactly on it.\n",
    "ref_flows = np.array([4.0, 2.0, 2.0, 2.0, 4.0])\n",
    "assert evaluator.evaluate(ref_flows)[\"relative_gap\"] < 1e-6\n",
    "assert np.allclose(final.link_flows, ref_flows, atol=0.01)\n",
    "print(f\"analytic UE flows       : {ref_flows}  (marouter within the mapping-floor perturbation)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee8ac905",
   "metadata": {},
   "source": [
    "## A2 — the MANDATORY cost-matched anchor\n",
    "\n",
    "The certified gap above is only INTERPRETABLE if marouter's own internal costs\n",
    "match the repo's declared BPR at the emitted flows on every representable link —\n",
    "otherwise the \"small gap\" could just as well be a cost-model mismatch. This\n",
    "notebook runs the SAME compile step + `marouter` invocation the adapter uses\n",
    "internally (via the public `_sumo_io` converter), reads marouter's own\n",
    "`traveltime` attribute, and diffs it against `scenario.network.link_cost` at the\n",
    "emitted flows. \"The row is not shipped without A2\" (adr-027)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "97c1983d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T13:55:32.660243Z",
     "iopub.status.busy": "2026-07-21T13:55:32.659938Z",
     "iopub.status.idle": "2026-07-21T13:55:33.533642Z",
     "shell.execute_reply": "2026-07-21T13:55:33.532560Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "braess    : 3/5 representable links, max |marouter cost - repo BPR cost| = 3.57e-10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "two-route : 2/4 representable links, max |marouter cost - repo BPR cost| = 1.56e-10\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import shutil\n",
    "import subprocess\n",
    "import tempfile\n",
    "\n",
    "\n",
    "def _run_marouter_direct(scenario, theta, paths, method=\"SUE\"):\n",
    "    # The adapter's own compile+run steps, exposed here to read marouter's\n",
    "    # INTERNAL traveltime attribute (not just the flows) -- the A2 cost-match check.\n",
    "    workdir = tempfile.mkdtemp(prefix=\"tabench-sumo-a2-\")\n",
    "    try:\n",
    "        build = sio.scenario_to_sumo(scenario, workdir, time_scale=1.0, min_lanes=1)\n",
    "        netload = os.path.join(workdir, \"nl.xml\")\n",
    "        cmd = [\n",
    "            sio.sumo_binary(\"marouter\"),\n",
    "            \"--net-file\", build.net_file, \"--additional-files\", build.taz_file,\n",
    "            \"--od-matrix-files\", build.od_file, \"--netload-output\", netload,\n",
    "            \"--output-file\", os.devnull, \"--precision\", \"9\",\n",
    "            \"--weights.minor-penalty\", \"0\", \"--left-turn-penalty\", \"0\",\n",
    "            \"--capacities.default\", \"true\", \"--assignment-method\", method,\n",
    "            \"--route-choice-method\", \"logit\", \"--logit.beta\", \"0\", \"--logit.gamma\", \"0\",\n",
    "            \"--logit.theta\", repr(float(theta)), \"--paths\", str(paths),\n",
    "            \"--max-iterations\", \"50\", \"--max-inner-iterations\", \"5000\",\n",
    "            \"--tolerance\", \"1e-7\", \"--seed\", \"42\", \"--routing-threads\", \"1\",\n",
    "        ]\n",
    "        proc = subprocess.run(cmd, env=sio.sumo_env(), capture_output=True, text=True, cwd=workdir)\n",
    "        assert proc.returncode == 0, proc.stderr[-1000:]\n",
    "        n = scenario.network.n_links\n",
    "        flows = sio.parse_netload(netload, n, build.flow_scale)\n",
    "        tt = sio.parse_netload_attr(netload, n, \"traveltime\")\n",
    "        return flows, tt, build\n",
    "    finally:\n",
    "        shutil.rmtree(workdir, ignore_errors=True)\n",
    "\n",
    "\n",
    "for sc, label in ((braess_scenario(), \"braess\"), (two_route_scenario(sue_theta=None), \"two-route\")):\n",
    "    # theta=200.0, paths=4: SumoMarouterModel()'s own defaults (logit_theta / time_scale\n",
    "    # at time_scale=1.0, and the \"paths\" factor) -- this must be the SAME run the model\n",
    "    # made above, or the cost-match check would not anchor A1/A3 at all.\n",
    "    flows_a2, tt, build = _run_marouter_direct(sc, 200.0, 4)\n",
    "    rep = build.representable\n",
    "    repo_cost = sc.network.link_cost(flows_a2)\n",
    "    diff = np.abs(tt[rep] / build.time_scale - repo_cost[rep])\n",
    "    print(f\"{label:10s}: {rep.sum()}/{len(rep)} representable links, \"\n",
    "          f\"max |marouter cost - repo BPR cost| = {diff.max():.2e}\")\n",
    "    assert rep.any()\n",
    "    assert diff.max() < 1e-6"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21c9ce33",
   "metadata": {},
   "source": [
    "## A3 — asymmetric two-route: feasibility is not equilibrium quality\n",
    "\n",
    "On the ASYMMETRIC two-route corridor (deterministic UE `f_A = 2.5` at `D=4`;\n",
    "`theta` is calibrated on THIS anchor, never symmetric Braess, whose UE is the\n",
    "equal split at any `theta`), `marouter` certifies a small but real gap while a\n",
    "converged white-box `bfw` certifies an orders-of-magnitude better one — the\n",
    "honest headline of this whole external-engine ladder: an industrially converged\n",
    "simulator run is not the same claim as a certified equilibrium."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a7c70527",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T13:55:33.537732Z",
     "iopub.status.busy": "2026-07-21T13:55:33.537522Z",
     "iopub.status.idle": "2026-07-21T13:55:33.769741Z",
     "shell.execute_reply": "2026-07-21T13:55:33.768737Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "marouter  : relative_gap = 5.445e-04\n",
      "bfw       : relative_gap = 0.000e+00  (an orders-of-magnitude better certificate)\n"
     ]
    }
   ],
   "source": [
    "sc_tr = two_route_scenario(sue_theta=None)\n",
    "bundle_tr = SumoMarouterModel().solve(sc_tr, Budget(iterations=50), RngBundle(42), Trace())\n",
    "metrics_tr = Evaluator(sc_tr).evaluate(bundle_tr.final.link_flows)\n",
    "print(f\"marouter  : relative_gap = {metrics_tr['relative_gap']:.3e}\")\n",
    "assert metrics_tr[\"feasible\"] == 1.0\n",
    "assert metrics_tr[\"relative_gap\"] < 1e-3\n",
    "\n",
    "bfw_trace = Trace()\n",
    "BiconjugateFrankWolfeModel().solve(\n",
    "    sc_tr, Budget(iterations=200, target_relative_gap=1e-10), RngBundle(0), bfw_trace\n",
    ")\n",
    "bfw_gap = Evaluator(sc_tr).evaluate(bfw_trace.final.link_flows)[\"relative_gap\"]\n",
    "print(f\"bfw       : relative_gap = {bfw_gap:.3e}  (an orders-of-magnitude better certificate)\")\n",
    "assert bfw_gap < metrics_tr[\"relative_gap\"] / 10.0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f633997d",
   "metadata": {},
   "source": [
    "## The honest negative control, and the traps this adapter refuses\n",
    "\n",
    "`marouter`'s DEFAULT `assignment_method=\"incremental\"` is NOT an equilibrium —\n",
    "certified here as a much worse gap, feasible but honestly far from UE. Three\n",
    "more traps are refused loudly rather than silently mis-scored:\n",
    "`assignment_method=\"UE\"` (marouter silently falls back to SUE — declaring it\n",
    "would poison the manifest), non-logit route choice (`gawron`/`lohse` emit\n",
    "all-zero flows in this macroscopic setting), and an SUE-scenario (marouter's\n",
    "adapter targets the deterministic instance only)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b3602282",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T13:55:33.773810Z",
     "iopub.status.busy": "2026-07-21T13:55:33.773604Z",
     "iopub.status.idle": "2026-07-21T13:55:34.429010Z",
     "shell.execute_reply": "2026-07-21T13:55:34.427946Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "incremental (default, NOT an equilibrium) : relative_gap = 7.128e-02  feasible = 1\n",
      "assignment_method='UE' refused : assignment_method='UE' is refused: marouter does not implement dete…\n",
      "route_choice='gawron' refused  : route_choice is restricted to 'logit' (gawron/lohse emit all-zero f…\n",
      "SUE-theta scenario refused     : sumo-marouter accepts only fixed-demand power==1 UE scenarios; scen…\n"
     ]
    }
   ],
   "source": [
    "bundle_inc = SumoMarouterModel(assignment_method=\"incremental\").solve(\n",
    "    scenario, Budget(iterations=50), RngBundle(42), Trace()\n",
    ")\n",
    "metrics_inc = Evaluator(scenario).evaluate(bundle_inc.final.link_flows)\n",
    "print(f\"incremental (default, NOT an equilibrium) : \"\n",
    "      f\"relative_gap = {metrics_inc['relative_gap']:.3e}  feasible = {metrics_inc['feasible']:.0f}\")\n",
    "assert metrics_inc[\"feasible\"] == 1.0\n",
    "assert metrics_inc[\"relative_gap\"] > 0.05  # honestly much worse than SUE's mapping floor\n",
    "\n",
    "try:\n",
    "    SumoMarouterModel(assignment_method=\"UE\").solve(scenario, Budget(iterations=5), RngBundle(0), Trace())\n",
    "    raise AssertionError(\"expected assignment_method='UE' to be refused\")\n",
    "except ValueError as exc:\n",
    "    print(f\"assignment_method='UE' refused : {exc}\"[:100] + \"…\")\n",
    "\n",
    "try:\n",
    "    SumoMarouterModel(route_choice=\"gawron\").solve(scenario, Budget(iterations=5), RngBundle(0), Trace())\n",
    "    raise AssertionError(\"expected route_choice='gawron' to be refused\")\n",
    "except ValueError as exc:\n",
    "    print(f\"route_choice='gawron' refused  : {exc}\"[:100] + \"…\")\n",
    "\n",
    "try:\n",
    "    SumoMarouterModel().solve(two_route_scenario(), Budget(iterations=5), RngBundle(0), Trace())\n",
    "    raise AssertionError(\"expected an SUE-theta scenario to be refused\")\n",
    "except ValueError as exc:\n",
    "    print(f\"SUE-theta scenario refused     : {exc}\"[:100] + \"…\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d441032e",
   "metadata": {},
   "source": [
    "## Visualize\n",
    "\n",
    "`sumo-marouter`'s certified artifact is per-LINK flows on a road `Network` —\n",
    "the same artifact shape every static/day-to-day model here emits — so\n",
    "`tabench.viz` applies directly (adr-035's viz rule)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7ae883c0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T13:55:34.432975Z",
     "iopub.status.busy": "2026-07-21T13:55:34.432786Z",
     "iopub.status.idle": "2026-07-21T13:55:34.722954Z",
     "shell.execute_reply": "2026-07-21T13:55:34.722286Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 480x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 480x460 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(viz.plot_network_flows(scenario.network, final.link_flows))\n",
    "display(viz.plot_flow_scatter((\"analytic UE\", ref_flows), {\"sumo-marouter (SUE)\": final.link_flows}))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f576059",
   "metadata": {},
   "source": [
    "## Takeaways & pointers\n",
    "\n",
    "- **Certified, not self-reported.** `marouter` reports no gap at all\n",
    "  (`provides_gap=False`); every number above came from the harness's own\n",
    "  `Evaluator`, recomputed from the emitted flows.\n",
    "- **A2 is the load-bearing anchor.** Without proving marouter's own costs match\n",
    "  the declared BPR on representable links, \"the gap is small\" would not mean\n",
    "  \"the mapping is faithful\" — it could just as well be a cost-model mismatch.\n",
    "- **Feasible is not equilibrium.** A3 makes the headline literal: `marouter`'s\n",
    "  industrially converged SUE and `bfw`'s certified equilibrium are DIFFERENT\n",
    "  claims, scored on the same axis, and `bfw` wins the convergence axis as\n",
    "  expected.\n",
    "- **Where next.** the compile-map derivation and every representability floor\n",
    "  in [docs/design/adr-027-sumo-marouter.md](../../docs/design/adr-027-sumo-marouter.md);\n",
    "  the white-box UE ladder this compares against\n",
    "  [`bfw`](../01-static/05-bfw.ipynb); the lineage in the\n",
    "  [model compendium](../../docs/MODELS.md)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.10.12"
  },
  "tabench": {
   "covers": [],
   "requires_extra": "sumo",
   "track": "external",
   "unit": "sumo-marouter"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}