{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c67dd2c3",
   "metadata": {},
   "source": [
    "# `od-congested` — Yang, Sasaki, Iida & Asakura's (1992) bilevel OD estimation\n",
    "\n",
    "**What.** `od-congested` (`Yang1992Estimator`, T2, ADR-002) is a bilevel\n",
    "program with a SINGLE trade-off dial `theta` (unlike `gls`'s per-cell\n",
    "covariance weighting): `min_g theta*(g-g_pr)'(g-g_pr) + (1-theta)*(p g -\n",
    "c)'(p g - c)`, solved as an inner MSA assignment feeding an outer QP with\n",
    "UNIFORM weighting on every cell/residual. It is the congested-network\n",
    "extension of the classical bilevel OD estimation literature (Yang 1995's\n",
    "sensitivity-analysis lineage traces back to this 1992 formulation).\n",
    "\n",
    "**Why it is in the benchmark.** `theta` gives an exact, hand-verifiable\n",
    "prior<->count spectrum (`theta->1` = pure prior, `theta->0` = pure count fit)\n",
    "that `gls`'s per-cell covariances do not expose as a single scalar — and\n",
    "because Yang's uniform weighting is mathematically DIFFERENT from `gls`'s\n",
    "per-cell variance weighting, the two estimators allocate an under-identified\n",
    "fit differently even though `yang_solve` IS `gls_solve` at specific scalar\n",
    "variances. See the [model compendium](../../docs/MODELS.md)\n",
    "(Yang, Sasaki, Iida & Asakura 1992) and\n",
    "[docs/design/adr-002-t2-estimation-certificate.md](../../docs/design/adr-002-t2-estimation-certificate.md)\n",
    "(P1).\n",
    "\n",
    "**Scope.** The scalar closed form and its exact `gls_solve` equivalence, the\n",
    "`theta` prior<->count spectrum, the uniform-vs-covariance weighting\n",
    "divergence, and the congested-network `theta->0` recovery on Braess.\n",
    "\n",
    "**Canon.** `[yang1992estimation]`, [docs/REFERENCES.md](../../docs/REFERENCES.md) / [docs/references.bib](../../docs/references.bib)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f85ce597",
   "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 — the closed forms are recomputed\n",
    "algebraically in-cell (no trusted digits), and the Braess recovery is\n",
    "recomputed by the P1 `ODCertifier` from the emitted OD matrix against the\n",
    "harness's own pinned BFW assignment, never from `od-congested`'s self-report\n",
    "([README](../../README.md), *Certified, not self-reported*)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cc7fe051",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T13:47:24.403098Z",
     "iopub.status.busy": "2026-07-21T13:47:24.402834Z",
     "iopub.status.idle": "2026-07-21T13:47:26.331779Z",
     "shell.execute_reply": "2026-07-21T13:47:26.330806Z"
    }
   },
   "outputs": [],
   "source": [
    "# Setup. `od-congested` is a core estimator: a plain `pip install -e .`\n",
    "# suffices — no optional extra, so no guard cell. The inline backend is\n",
    "# Agg-based (headless CI renders into the notebook); NEVER\n",
    "# matplotlib.use(\"Agg\") in-kernel — it silently suppresses inline capture.\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "\n",
    "from tabench import (\n",
    "    Budget,\n",
    "    Demand,\n",
    "    ODCertifier,\n",
    "    RngBundle,\n",
    "    Trace,\n",
    "    braess_scenario,\n",
    "    two_route_scenario,\n",
    "    viz,\n",
    ")\n",
    "from tabench.core.rng import SOURCE_OBSERVATION\n",
    "from tabench.estimation import ODTrace, Yang1992Estimator, gls_solve, yang_solve\n",
    "from tabench.estimation.base import EstimationTask\n",
    "from tabench.models.frank_wolfe import BiconjugateFrankWolfeModel\n",
    "from tabench.observe.levels import LinkCounts\n",
    "\n",
    "BRAESS_TRUTH = np.array([4.0, 2.0, 2.0, 2.0, 4.0])  # UE(D=6), recomputed below\n",
    "TWOROUTE_TRUTH = np.array([2.5, 2.5, 1.5, 1.5])  # UE(D=4), recomputed below\n",
    "\n",
    "# Analytic anchors recomputed, never quoted: pin both by an independent\n",
    "# high-precision BFW solve before EITHER constant is used as a data-generating\n",
    "# truth anywhere below.\n",
    "def _pinned_ue(scenario):\n",
    "    trace = Trace()\n",
    "    BiconjugateFrankWolfeModel().solve(\n",
    "        scenario, Budget(iterations=5000, target_relative_gap=1e-10), RngBundle(0), trace\n",
    "    )\n",
    "    return trace.final.link_flows\n",
    "\n",
    "np.testing.assert_allclose(_pinned_ue(braess_scenario(6.0)), BRAESS_TRUTH, atol=1e-6)\n",
    "np.testing.assert_allclose(_pinned_ue(two_route_scenario(sue_theta=None)), TWOROUTE_TRUTH, atol=1e-6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67cd5ff6",
   "metadata": {},
   "source": [
    "## The closed form: `theta`-weighted, and exactly a `gls` special case\n",
    "\n",
    "Single pair, single sensor: `g* = (theta*g_pr + (1-theta)*p*c) / (theta +\n",
    "(1-theta)*p^2)`. At the scalar variances `W=1/theta, V=1/(1-theta)`, this is\n",
    "LITERALLY `gls_solve` — the exact sense in which `od-congested` is the\n",
    "deterministic-tradeoff special case of generalized least squares."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6a0df4bb",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T13:47:26.336349Z",
     "iopub.status.busy": "2026-07-21T13:47:26.335910Z",
     "iopub.status.idle": "2026-07-21T13:47:26.342927Z",
     "shell.execute_reply": "2026-07-21T13:47:26.342253Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "theta=0.2: yang_solve=3.609756  closed form=3.609756  via gls_solve=3.609756\n",
      "theta=0.5: yang_solve=3.280899  closed form=3.280899  via gls_solve=3.280899\n",
      "theta=0.8: yang_solve=3.088968  closed form=3.088968  via gls_solve=3.088968\n"
     ]
    }
   ],
   "source": [
    "p, c, g_pr = 0.625, 2.5, 3.0\n",
    "for theta in (0.2, 0.5, 0.8):\n",
    "    expected = (theta * g_pr + (1 - theta) * p * c) / (theta + (1 - theta) * p * p)\n",
    "    got = yang_solve(np.array([[p]]), np.array([c]), np.array([g_pr]), theta)\n",
    "    via_gls = gls_solve(\n",
    "        np.array([[p]]), np.array([c]), np.array([g_pr]),\n",
    "        np.array([1.0 / theta]), np.array([1.0 / (1.0 - theta)]),\n",
    "    )\n",
    "    print(f\"theta={theta}: yang_solve={got[0]:.6f}  closed form={expected:.6f}  via gls_solve={via_gls[0]:.6f}\")\n",
    "    assert np.isclose(got[0], expected, atol=1e-10)\n",
    "    assert np.isclose(got[0], via_gls[0], atol=1e-9)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aee0dff9",
   "metadata": {},
   "source": [
    "## The distinctive knob: `theta` spans the whole prior<->count spectrum\n",
    "\n",
    "`theta -> 1` recovers the prior exactly; `theta -> 0` fits the count exactly\n",
    "(`c/p`) — the single scalar dial this estimator is named for."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8ed8a333",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T13:47:26.346477Z",
     "iopub.status.busy": "2026-07-21T13:47:26.346107Z",
     "iopub.status.idle": "2026-07-21T13:47:26.351024Z",
     "shell.execute_reply": "2026-07-21T13:47:26.350345Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "theta->1 (near_prior) : 1.000000  (prior: 1.0)\n",
      "theta->0 (near_count) : 6.000000  (c/p: 6.000000)\n"
     ]
    }
   ],
   "source": [
    "p2, c2, g_pr2 = 0.5, 3.0, 1.0\n",
    "near_prior = yang_solve(np.array([[p2]]), np.array([c2]), np.array([g_pr2]), 1 - 1e-8)[0]\n",
    "near_count = yang_solve(np.array([[p2]]), np.array([c2]), np.array([g_pr2]), 1e-8)[0]\n",
    "print(f\"theta->1 (near_prior) : {near_prior:.6f}  (prior: {g_pr2})\")\n",
    "print(f\"theta->0 (near_count) : {near_count:.6f}  (c/p: {c2 / p2:.6f})\")\n",
    "assert np.isclose(near_prior, g_pr2, atol=1e-4)\n",
    "assert np.isclose(near_count, c2 / p2, atol=1e-4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4ebc009",
   "metadata": {},
   "source": [
    "## Not a `gls` rename: uniform vs per-cell covariance weighting\n",
    "\n",
    "Given a count the prior does NOT already satisfy, `gls` loads most of the\n",
    "adjustment onto the more-uncertain (large-prior) cell (per-cell covariance\n",
    "`W`), while `od-congested`'s uniform `theta` splits the residual evenly\n",
    "across cells — so the two allocate the fit differently, not just by a\n",
    "constant rescaling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "581dad4f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T13:47:26.354882Z",
     "iopub.status.busy": "2026-07-21T13:47:26.354380Z",
     "iopub.status.idle": "2026-07-21T13:47:26.360540Z",
     "shell.execute_reply": "2026-07-21T13:47:26.359857Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yang_solve (uniform)         : [3.3333 9.3333]\n",
      "gls_solve (per-cell weighted): [ 2.2222 11.5556]\n",
      "max |yang - gls|             : 2.2222\n"
     ]
    }
   ],
   "source": [
    "p_obs = np.array([[1.0, 1.0]])  # one sensor sees both pairs\n",
    "c3 = np.array([14.0])            # prior sum (2+8=10) does NOT match it\n",
    "g_pr3 = np.array([2.0, 8.0])    # priors of very different magnitude\n",
    "yang = yang_solve(p_obs, c3, g_pr3, 0.5)          # uniform weighting: near-even split\n",
    "w_var = (0.5 * g_pr3) ** 2 + 1e-6                  # gls: large-prior cell far more uncertain\n",
    "gls = gls_solve(p_obs, c3, g_pr3, w_var, np.array([1.0]))\n",
    "print(f\"yang_solve (uniform)         : {np.round(yang, 4)}\")\n",
    "print(f\"gls_solve (per-cell weighted): {np.round(gls, 4)}\")\n",
    "print(f\"max |yang - gls|             : {np.abs(yang - gls).max():.4f}\")\n",
    "assert np.abs(yang - gls).max() > 0.5\n",
    "# gls moves the uncertain (large-prior) cell much more than yang's uniform split.\n",
    "assert (gls[1] - g_pr3[1]) > (yang[1] - g_pr3[1]) + 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fa95906",
   "metadata": {},
   "source": [
    "## Congested-network recovery: `theta->0` trusts the counts\n",
    "\n",
    "On both the convex two-route corridor (`D=4`) and the Braess network\n",
    "(`D=6`, from the global-basin prior `D=5.5` — see\n",
    "[`spiess`](02-spiess.ipynb) for the SPURIOUS-basin caveat this same network\n",
    "has), the bilevel outer fixed point recovers the equilibrium-consistent\n",
    "truth as `theta -> 0` (count-trusting); at `theta -> 1` it instead holds at\n",
    "the prior. `braess_scenario(6.0)` is frozen and content-hashed (P2)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2ced59aa",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T13:47:26.364381Z",
     "iopub.status.busy": "2026-07-21T13:47:26.363976Z",
     "iopub.status.idle": "2026-07-21T13:47:31.624807Z",
     "shell.execute_reply": "2026-07-21T13:47:31.623298Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "two-route: theta->0 = 3.9991 (target 4.0); theta->1 = 3.0000 (prior 3.0)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "braess: theta->0 = 5.9996 (target 6.0); theta->1 = 5.5000 (prior 5.5)\n",
      "content hash  : cf00f411cdccec88…\n",
      "certified od_rmse (Braess, theta->0) : 2.8932e-04\n"
     ]
    }
   ],
   "source": [
    "def _single_pair_prior(d):\n",
    "    m = np.zeros((2, 2))\n",
    "    m[0, 1] = d\n",
    "    return m\n",
    "\n",
    "\n",
    "def _task(scenario, truth, sensors, prior_matrix):\n",
    "    ds = LinkCounts(np.asarray(sensors), 1, \"none\").observe(\n",
    "        scenario, truth, RngBundle(0).generator(SOURCE_OBSERVATION)\n",
    "    )\n",
    "    return EstimationTask(\n",
    "        name=\"t\", network=scenario.network, prior=Demand(np.asarray(prior_matrix, dtype=np.float64)),\n",
    "        dataset=ds, identifiability={}, scenario_hash=scenario.content_hash(), seed=0,\n",
    "    )\n",
    "\n",
    "\n",
    "budget = Budget(sp_calls=10**9, iterations=200)\n",
    "for scenario_fn, truth, prior_d, target, label in (\n",
    "    (lambda: two_route_scenario(sue_theta=None), TWOROUTE_TRUTH, 3.0, 4.0, \"two-route\"),\n",
    "    (lambda: braess_scenario(6.0), BRAESS_TRUTH, 5.5, 6.0, \"braess\"),\n",
    "):\n",
    "    sc = scenario_fn()\n",
    "    task = _task(sc, truth, np.arange(len(truth)), _single_pair_prior(prior_d))\n",
    "    trace_count = ODTrace()\n",
    "    Yang1992Estimator(k_inner=120, outer_iters=80, theta=1e-3).estimate(\n",
    "        task, budget, RngBundle(0), trace_count\n",
    "    )\n",
    "    trace_prior = ODTrace()\n",
    "    Yang1992Estimator(k_inner=120, outer_iters=30, theta=1 - 1e-6).estimate(\n",
    "        task, budget, RngBundle(0), trace_prior\n",
    "    )\n",
    "    d_count, d_prior = trace_count.final.od_matrix[0, 1], trace_prior.final.od_matrix[0, 1]\n",
    "    print(f\"{label}: theta->0 = {d_count:.4f} (target {target}); \"\n",
    "          f\"theta->1 = {d_prior:.4f} (prior {prior_d})\")\n",
    "    assert abs(d_count - target) < 1e-2\n",
    "    assert abs(d_prior - prior_d) < 1e-2\n",
    "\n",
    "sc_final = braess_scenario(6.0)\n",
    "print(f\"content hash  : {sc_final.content_hash()[:16]}…\")\n",
    "certifier = ODCertifier(\n",
    "    sc_final, np.arange(5), np.array([], dtype=np.int64),\n",
    "    BRAESS_TRUTH[None, :], BRAESS_TRUTH[[]][None, :], BRAESS_TRUTH,\n",
    "    {\"linear_identifiable\": True},\n",
    ")\n",
    "metrics = certifier.certify(trace_count.final.od_matrix)\n",
    "print(f\"certified od_rmse (Braess, theta->0) : {metrics['od_rmse']:.4e}\")\n",
    "assert metrics[\"od_feasible\"] == 1.0\n",
    "assert metrics[\"od_rmse\"] < 1e-2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8b0c74e",
   "metadata": {},
   "source": [
    "## Visualize\n",
    "\n",
    "`tabench.viz` draws the road `Network`'s link flows for the count-trusting\n",
    "(`theta->0`) recovery vs the prior-holding (`theta->1`) estimate on Braess,\n",
    "both re-assigned from the certified OD matrices above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "002ed48f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-21T13:47:31.629893Z",
     "iopub.status.busy": "2026-07-21T13:47:31.629603Z",
     "iopub.status.idle": "2026-07-21T13:47:31.958149Z",
     "shell.execute_reply": "2026-07-21T13:47:31.957267Z"
    }
   },
   "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": [
    "from tabench import Scenario\n",
    "count_trace = Trace()\n",
    "BiconjugateFrankWolfeModel().solve(\n",
    "    Scenario(\"count-trusting\", sc_final.network, Demand(trace_count.final.od_matrix), family=sc_final.family),\n",
    "    Budget(iterations=5000, target_relative_gap=1e-10), RngBundle(0), count_trace,\n",
    ")\n",
    "prior_hold_trace = Trace()\n",
    "BiconjugateFrankWolfeModel().solve(\n",
    "    Scenario(\"prior-holding\", sc_final.network, Demand(trace_prior.final.od_matrix), family=sc_final.family),\n",
    "    Budget(iterations=5000, target_relative_gap=1e-10), RngBundle(0), prior_hold_trace,\n",
    ")\n",
    "display(viz.plot_network_flows(sc_final.network, BRAESS_TRUTH))\n",
    "display(viz.plot_flow_scatter(\n",
    "    (\"truth (D=6)\", BRAESS_TRUTH),\n",
    "    {\"theta->0 (count-trusting)\": count_trace.final.link_flows,\n",
    "     \"theta->1 (prior-holding)\": prior_hold_trace.final.link_flows},\n",
    "))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f23a060",
   "metadata": {},
   "source": [
    "## Takeaways & pointers\n",
    "\n",
    "- **Certified, not self-reported.** The Braess `od_rmse` above came from\n",
    "  `ODCertifier`'s own re-assignment of the emitted OD matrix, never from\n",
    "  `od-congested`'s inner-MSA proportions.\n",
    "- **A single scalar dial, exactly a `gls` special case at fixed variances —\n",
    "  but not a rename at the estimator level.** Uniform-vs-per-cell weighting\n",
    "  is verified above to allocate an under-identified fit differently.\n",
    "- **Where next.** the per-cell-covariance sibling\n",
    "  [`gls`](01-gls.ipynb); the count-only end of the spectrum\n",
    "  [`spiess`](02-spiess.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": null,
   "track": "estimation",
   "unit": "od-congested"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}