Add files using upload-large-folder tool

README.md

@@ -1,3 +1,621 @@
----
-license: mit
----
+---
+license: mit
+pretty_name: Semantic Potential Routing Telemetry
+language:
+- en
+task_categories:
+- time-series-forecasting
+- tabular-regression
+- graph-ml
+tags:
+- networking
+- routing
+- graph-theory
+- operations-research
+- physics-based-simulation
+- telemetry
+- microbursts
+- data-center-networks
+- benchmark
+- synthetic
+size_categories:
+- 100M<n<1B
+configs:
+- config_name: router_summary
+  data_files: data/router_summary/*.parquet
+- config_name: flow_summary
+  data_files: data/flow_summary/*.parquet
+- config_name: episodes
+  data_files: data/episodes/*.parquet
+- config_name: events
+  data_files: data/events/*.parquet
+- config_name: network_telemetry
+  data_files: data/network_telemetry/*.parquet
+- config_name: flow_telemetry
+  data_files: data/flow_telemetry/*.parquet
+- config_name: link_telemetry
+  data_files: data/link_telemetry/*.parquet
+- config_name: potential_field
+  data_files: data/potential_field/*.parquet
+---
+
+# Semantic Potential Routing Telemetry
+
+**Version 2.0** — a systematic, packet-level benchmark of **training-free potential-field routing** against
+classical routing under stochastic congestion, dynamic topologies and microburst traffic.
+
+Every episode is a network simulation in which routing is a physical field: each flow's destination is the
+grounded, attractive well of a discrete Poisson equation on the graph Laplacian, congested buffers inject
+repulsive current, and packets follow the resulting routing gradient without any learned weights. The same
+episode — identical topology, failure timeline and packet arrivals — is replayed under **six routers**: three
+potential-field variants (steepest descent, proportional multipath splitting, and a static ablation without
+congestion feedback) and three classical baselines (static shortest path, equal-cost multipath, and
+queue-aware adaptive shortest path). Episodes are laid out on a **full factorial design** over topology
+family, network size, traffic profile, offered load and topology dynamics, so every effect can be studied
+in isolation, and the recorded telemetry is step-resolved: buffer occupancy and drops of every node, load of
+every directed link, per-flow delivery and delay, and the potential field itself.
+
+Everything is generated on CPU with linear algebra and a vectorised queueing simulator: no GPU, no
+training, no external data. The generator ships in this repository, and any episode can be re-created bit
+for bit from `data/config.json` and its episode id.
+
+## Experimental design
+
+Episodes belong to the cells of a five-factor factorial design (`src/design.py`). With the default 10
+replicates per cell the dataset holds **5 × 4 × 3 × 3 × 3 = 540 cells and 5,400 episodes**, each replayed
+under all six routers.
+
+| Factor | Levels | Meaning |
+|---|---|---|
+| `topology` | `barabasi_albert`, `watts_strogatz`, `erdos_renyi`, `waxman`, `fat_tree` | scale-free (router-level Internet), small-world, random, geometric ISP-like (distance latencies, coordinates), k-ary data-centre fabric (hosts are the endpoints, 2:1 oversubscribed edge) |
+| `size` | 32, 64, 128, 256 | nominal node count; fat-trees use k = 4, 6, 8, 10 (36, 99, 208, 375 nodes) |
+| `traffic_profile` | `poisson`, `microburst`, `sustained` | stationary Poisson; short intense bursts (peak/idle 16, mean 15-step bursts, 13 % duty); long moderate surges (peak/idle 4, 50 % duty) |
+| `load_level` | `light`, `moderate`, `heavy` | offered load ρ = 0.01, 0.03, 0.10 of the network's directed link capacity (defined below) |
+| `dynamics_level` | `static`, `moderate`, `severe` | no events; link failures and node degradations at 0.002/step each lasting 50–200 steps; 0.01/step lasting 100–400 steps |
+
+Episode `e` maps deterministically to cell `e mod 540` and replicate `e div 540`, so any prefix of the
+episode range — including a partially generated or resumed dataset — covers all cells evenly. Replicates
+are assigned to splits by `replicate mod 5`: 0–2 train, 3 validation, 4 test (60/20/20), recorded in
+`episodes.split`. Random families are generated at a common mean degree of 6, so network size is the only
+structural quantity that changes with the size factor.
+
+## Tables
+
+The dataset is a relational schema of eight Parquet tables, one folder each under `data/`, sharded by
+episode (`part-00000.parquet`, …) and served as separate configurations on the Hub, so you download only
+what you need. Node ids are `0 … n_nodes−1`, flows `0 … n_flows−1`, and one step is one millisecond of
+simulated time. Every telemetry row carries `episode_id`, `router` and `step`.
+
+**`episodes`** — one row per episode: design cell (`cell_id`, `replicate`, `split`, `topology`, `size`,
+`traffic_profile`, `load_level`, `dynamics_level`), dimensions (`n_nodes`, `n_edges`, `n_flows`,
+`tracked_flows`, `steps`, `field_stride`), `offered_load` (ρ) and `total_capacity` (Σ directed link
+capacity), the static graph (`edge_u`, `edge_v` with `u < v` in a fixed order; per-link `capacity` in
+packets/step and `latency` in steps; `node_role` 0 router / 1 core / 2 aggregation / 3 edge / 4 host;
+`node_x`, `node_y` for Waxman graphs, empty otherwise) and the flows (`flow_source`, `flow_sink`,
+`flow_mean_rate`, `flow_idle_rate`, `flow_burst_rate`, plus the MMPP transition probabilities
+`p_idle_to_burst`, `p_burst_to_idle`, zero for the Poisson profile).
+
+**`events`** — one row per topology event, active for `start <= step < end`: `kind` (`link_failure`: the
+link's capacity is 0; `node_degradation`: all links of `node` are scaled by `factor`), `edge_u`/`edge_v` or
+`node` (−1 where not applicable).
+
+**`router_summary`** — one row per (episode, router): `offered`, `delivered`, `dropped`, `in_flight`,
+`loss_ratio`, `mean_delay`, `p99_delay`, `mean_queue`, `max_queue`, `link_utilisation` (packets forwarded /
+directed link capacity over all link-steps), `link_saturation` (fraction of directed link-steps at full
+capacity), `route_changes` (next-hop table entries that changed, summed over steps and flows).
+
+**`flow_summary`** — one row per (episode, router, flow): `source`, `sink`, `mean_rate`, `min_hops`,
+`min_latency` (shortest path on the base graph), `offered`, `delivered`, `dropped`, `in_flight`,
+`loss_ratio`, `mean_delay`, `delay_std`, `p50_delay`, `p95_delay`, `p99_delay`, `max_delay`,
+`mean_queueing_delay`, `mean_path_latency` (delay = queueing + propagation), `mean_hops`, `route_changes`.
+
+**`network_telemetry`** — one row per (episode, router, step): network totals `offered`, `admitted`,
+`delivered`, `dropped`, `queued`, `in_transit`, `mean_delay` (of packets delivered this step, NaN if none),
+`route_changes`, and two lists of length `n_nodes`: `queue_depth` (buffer occupancy after the step's
+arrivals were admitted and before forwarding, i.e. what the router sees) and `node_dropped`.
+
+**`flow_telemetry`** — one row per (episode, router, step, tracked flow) for the first `tracked_flows` (8)
+flows of every episode: `mmpp_state` (0 idle, 1 burst), `offered`, `admitted`, `delivered`, `dropped`,
+`queued`, `in_transit`, `mean_delay`, `route_changes`.
+
+**`link_telemetry`** — one row per (episode, router, step): `load_uv` and `load_vu`, lists of length
+`n_edges` with the packets forwarded over each link in the `u → v` and `v → u` directions.
+
+**`potential_field`** — one row per logged step of the `potential` router: `potential`, a list of
+`tracked_flows × n_nodes` float32 values, flow-major, with φ = 0 at each flow's sink. Steps are logged every
+`field_stride` steps (2 for 32-node graphs, 12 for the largest fat-trees) so that each episode's field
+stays within 1 MB; any step and any flow can be recomputed exactly from the other tables (see below).
+
+With the defaults, `flow_telemetry` holds about 260 M rows (5,400 episodes × 6 routers × 1,000 steps × 8
+tracked flows) and `network_telemetry` and `link_telemetry` 32.4 M each; the whole dataset is roughly 20 GB,
+three quarters of it the two per-step list tables. The summary tables are a few hundred MB and answer most
+benchmark questions on their own. **None of the step-level tables fits in memory** — read them with column
+projection and `episode_id` / `router` filters, or stream them shard by shard as
+`scripts/validate_dataset.py` does.
+
+All list columns (`queue_depth`, `node_dropped`, `load_uv`, `load_vu`, `capacity`, `latency`, …) are
+**int16** to keep the files small. Widen them before arithmetic — `np.stack(net.queue_depth) * 160`
+silently overflows, `np.stack(net.queue_depth).astype(float) * 160` does not.
+
+## Simulation model
+
+**Topologies.** Barabási–Albert (m = 3), connected Watts–Strogatz (k = 6, p = 0.1) and Erdős–Rényi
+(p = 6/(n−1)) graphs; Waxman graphs with uniformly random coordinates in the unit square and link
+preference exp(−d / 0.15√2), drawn with an exact edge count for mean degree 6 and latency proportional to
+distance; and k-ary fat-trees (k²/4 core, k² pod switches, k³/4 hosts) with 40 packets/step fabric links
+and 80 packets/step host links. Random-graph links have integer capacities uniform in 8–80 packets/step
+(≈ 100–1 000 Mb/s for 1 500-byte packets at 1 ms steps) and latencies uniform in 1–10 steps. A disconnected
+Erdős–Rényi or Waxman sample is stitched into one component by joining each stray component to the main
+one (closest pair of nodes for geometric graphs), which adds on average fewer than 0.2 links per graph
+below 128 nodes and about one link per graph at 256 nodes, so the node count is always the nominal one.
+
+**Dynamics.** Independently each step a link fails or a node degrades with the level's probability; failed
+links are chosen only among the non-bridge links of the live graph, so the network never partitions and the
+question of interest — how quickly traffic routes around the damage — is always well posed. A degraded node
+multiplies the capacity of all its links by a factor in 0.1–0.5. Effective capacities are
+`max(1, ⌊capacity × factor_u × factor_v⌋)`, or 0 while failed, and follow from `episodes` + `events`.
+
+**Traffic.** Each episode has two flows per endpoint node between distinct ordered (source, sink) pairs.
+Per-flow mean rates are log-normal (σ = 0.75, elephants and mice) and rescaled so that the offered load
+`ρ = Σ_f m_f · hops_f / Σ_links capacity` — the share of the network's directed capacity the flows would
+occupy on their shortest paths — equals the cell's level exactly. Each flow is a two-state Markov-modulated
+Poisson process whose idle and burst rates are derived from its mean rate and the profile's peak ratio and
+duty cycle, so profiles differ in burstiness at equal long-run load.
+
+**Queueing.** Every node owns one drop-tail FIFO buffer of 256 packets shared by all flows. Each step, in
+order: new packets are created at their sources; packets reaching a node this step are delivered if the
+node is their sink, otherwise admitted oldest-first while space remains, the rest dropped; buffers are
+logged and routing decisions taken; then every directed link forwards, oldest first, up to its capacity of
+the packets whose next hop crosses it (virtual output queueing, no head-of-line blocking). A packet
+forwarded at step `t` over a link of latency ℓ arrives at `t + ℓ`, so delay is propagation plus queueing,
+and a packet already on the wire is unaffected by a failure of that link. Traffic is open-loop: there is no
+congestion control, which is what makes the routers' behaviour under overload comparable.
+
+## Routers
+
+| router | decision | recomputed | capacity-aware | congestion-aware | multipath |
+|---|---|---|---|---|---|
+| `potential` | link with the largest current I_ij = w_ij(φ_i − φ_j) | every step | yes | yes | no |
+| `potential_split` | packets sprayed in proportion to the positive currents | every step | yes | yes | yes |
+| `potential_static` | largest current of the field without congestion injection | topology change | yes | no | no |
+| `shortest_path` | Dijkstra on latency (OSPF-like) | topology change | no | no | no |
+| `ecmp` | round-robin over all equal-latency shortest-path next hops | topology change | no | no | yes |
+| `adaptive_shortest_path` | Dijkstra on latency + queue / capacity, quantised to 10⁻⁶ steps (ARPANET-style) | every step | partly | yes | no |
+
+**Potential field.** For flow *f* with source *s* and sink *t*,
+
+```
+L_g φ = b,   L = D − W,   w_ij = capacity_ij / latency_ij   (live links only)
+b_i = source_injection · [i = s] + background_injection / (N − 1) + congestion_gain · queue_i / buffer_size
+```
+
+where `L_g` is the weighted graph Laplacian with the sink's row and column removed — the Dirichlet condition
+φ_t = 0 that makes the sink the grounded well of the field (defaults 1.0, 0.5 and 2.0). The grounded inverse
+is available in closed form from the Laplacian pseudo-inverse, `(L_g⁻¹)_ij = L⁺_ij − L⁺_it − L⁺_tj + L⁺_tt`,
+and because the background and congestion injections are shared by all flows, the fields of all flows follow
+from one matrix–vector product with L⁺ plus O(N) work per flow; L⁺ is formed once per topology change. On
+every live directed link the current is I_ij = w_ij(φ_i − φ_j). Since b_i > 0 at every non-sink node,
+Σ_j I_ij = b_i > 0: at least one current is positive and every positive-current link leads strictly
+downhill, so both potential rules are loop-free and reach the sink in at most N − 1 hops for *any*
+congestion pattern — congestion bends routes but can never trap a packet. Proportional splitting is the
+physically faithful rule (electrical current divides over parallel paths); it uses a low-discrepancy
+per-packet coordinate so that the split is exact and the simulation stays deterministic.
+
+**Baselines.** `shortest_path` is the classic link-state behaviour, blind to capacity and queues but
+reacting to failures. `ecmp` spreads packets over all equal-cost paths, the data-centre default. The
+adaptive baseline recomputes Dijkstra each step with link cost latency + queue/capacity, the queue-aware
+policy that famously oscillates; its `route_changes` make that visible. Together with `potential_static`,
+the suite separates the value of capacity awareness, congestion awareness and multipath.
+
+On the defaults, at moderate load with microbursts, mean loss over episodes is about 1 % for `potential`,
+under 0.5 % for `potential_split` and `adaptive_shortest_path`, 2–3 % for `potential_static` and around
+10 % for `shortest_path` and `ecmp`. At heavy load every router loses packets: a few percent for the
+adaptive ones, about 20 % for the static potential field and a third or more for shortest path and ECMP.
+The multipath and static potential variants pay for their robustness with longer paths (path stretch
+about 1.4–1.5 against 1.2 for the others), and the adaptive routers change next hops several orders of
+magnitude more often than the static baselines.
+
+## Generating the dataset
+
+Any Python ≥ 3.9 environment works; the commands below are written with forward slashes, which both
+PowerShell and POSIX shells accept.
+
+```bat
+cd "<path to this repository>"
+pip install -r requirements.txt
+```
+
+Check the whole pipeline end to end in about a minute — fifteen short episodes covering every topology
+family, traffic profile and router in a temporary folder that is deleted afterwards:
+
+```bat
+python scripts/run_local_sweep.py --smoke
+```
+
+Generate the dataset (5,400 episodes on every logical core, shards of 40 episodes streamed to `data/`):
+
+```bat
+python scripts/run_local_sweep.py
+```
+
+An episode costs roughly 3–7 s of CPU at size 32, 6–13 s at 64, 20–35 s at 128 and 60–100 s at 256
+(six routers, 1 000 steps; heavier load and larger fabrics cost more), i.e. about 4–5 CPU-hours per
+replicate: expect the default run to take **one night on an 8-core laptop** and to write about 20 GB.
+Keep the machine plugged in with sleep disabled. The sweep
+prints progress with an ETA, and if it is interrupted, running the same command again resumes with the
+missing shards; when it finishes it writes `data/manifest.json` (provenance, coverage, table sizes) and
+prints the router benchmark. `data/config.json` binds the folder to its configuration, so a changed setting
+must go to another `--out` folder.
+
+Every design level and model knob is a flag (`python scripts/run_local_sweep.py --help`). A half-size run
+with exact 60/20/20 splits, a smaller design, or a potential-field-only run:
+
+```bat
+python scripts/run_local_sweep.py --replicates 5
+python scripts/run_local_sweep.py --sizes 32,64 --topologies barabasi_albert,fat_tree --out data_small
+python scripts/run_local_sweep.py --routers potential,shortest_path --out data_pair
+```
+
+Requirements: Python ≥ 3.9 with NumPy, SciPy, pandas, PyArrow, NetworkX, huggingface_hub and, for the
+figures, Matplotlib (`requirements.txt`). Workers use one BLAS thread each; all parallelism comes from the
+process pool.
+
+## Validating a generated dataset
+
+`scripts/validate_dataset.py` is the test suite of a data folder. It re-derives every quantity it can from
+an independent path and compares, rather than merely re-reading what the generator wrote:
+
+```bat
+python scripts/validate_dataset.py                                :: validates data/
+python scripts/validate_dataset.py --out data_small --resimulate 5
+```
+
+| Group | What is checked |
+|---|---|
+| Structure | every table has the same number of shards; `manifest.json` present |
+| Design coverage | all cells present, replicates balanced to ±1, episode ids unique, the three splits present |
+| Invariants | `offered = delivered + dropped + in_flight`; loss ratio in [0, 1]; `mean_delay ≥ min_latency` and `mean_hops ≥ min_hops`; delay quantiles ordered; `mean_delay = mean_queueing_delay + mean_path_latency`; `flow_summary` sums to `router_summary`; `network_telemetry` and `flow_telemetry` sum to their summaries per (episode, router[, flow]); `admitted ≤ offered` on every step; link utilisation and saturation in [0, 1] |
+| Physical bounds (sampled episodes) | buffer occupancy within `buffer_size`; per-node drops sum to the step total; link loads never exceed the capacity in force at that step (recomputed from `episodes` + `events`); potentials non-negative and exactly 0 at each flow's sink |
+| Reproducibility | sampled episodes re-simulated from `config.json` alone and compared **bit for bit**, every table and column (NaN equal to NaN) |
+| Field reconstruction | one stored `potential_field` snapshot recovered from the graph state and queue depths with the sparse SuperLU reference solver, independent of the pseudo-inverse path used by the generator |
+
+Sampled episodes are the smallest, the largest and one drawn at random (`--seed`); `--resimulate` sets how
+many are re-simulated. Every line is printed as `[ok ]` or `[FAIL]`, the script exits **1** with a summary
+of the failures if anything is wrong, and a failing cross-table sum names the first group that differs
+(abridged output of a full default run):
+
+```
+Structure
+  [ok ] 135 shards present
+  [ok ] every table has every shard
+  [ok ] manifest.json present
+Design coverage
+  [ok ] all 540 design cells present
+  [ok ] balanced: 10-10 episodes per cell
+  [ok ] episode ids unique
+  [ok ] splits present: ['test', 'train', 'validation']
+Invariants
+  [ok ] flow conservation: offered = delivered + dropped + in-flight
+  ...
+  [ok ] tracked-flow telemetry sums to the flow summary
+  [ok ] admitted <= offered
+Physical bounds (sampled episodes)
+  [ok ] episode 0: queue depths within the buffer
+  [ok ] episode 0: link loads never exceed the capacity in force
+  [ok ] episode 0: potentials non-negative and zero at the sinks
+Reproducibility (re-simulating from config.json)
+  [ok ] episode 0: every table reproduced bit for bit
+Potential-field reconstruction (sparse reference solver)
+  [ok ] episode 0, step 100: stored field matches the sparse solve (max rel err 4.5e-08)
+
+Dataset v2.0: 5400 episodes, 20.14 GB
+All checks passed.
+```
+
+**Memory.** The cross-table checks never load a step-level table. The shards are scanned one record batch
+at a time (`--batch-rows`, default 262,144) and folded into a dense accumulator whose size is fixed by the
+design — episodes × routers × tracked flows, about 260 k slots — not by the 260 M rows being read. Peak
+resident memory is therefore flat in dataset size: **well under 1 GB** for the full 20 GB dataset, of which
+the PyArrow buffers are about 20 MB. The invariant pass costs roughly a minute per 10 GB on one core; the
+re-simulation of a few episodes dominates the total runtime.
+
+A quick end-to-end rehearsal of generation *and* validation, in about two minutes:
+
+```bat
+python scripts/run_local_sweep.py --out data_tiny --sizes 32 --replicates 5 --steps 200 --shard_episodes 25
+python scripts/validate_dataset.py --out data_tiny
+python examples/benchmark_routers.py --data data_tiny
+```
+
+## Using the data
+
+```python
+import numpy as np, pandas as pd
+
+rs = pd.read_parquet("data/router_summary")
+ep = pd.read_parquet("data/episodes").set_index("episode_id")
+df = rs.join(ep[["topology", "size", "traffic_profile", "load_level", "dynamics_level", "split"]], on="episode_id")
+print(df.pivot_table(index=["traffic_profile", "load_level"], columns="router", values="loss_ratio"))
+
+# One episode, step by step
+eid = 7
+net = pd.read_parquet("data/network_telemetry", filters=[("episode_id", "=", eid), ("router", "=", "potential")]).sort_values("step")
+queue = np.stack(net.queue_depth).astype(np.int32)                   # (steps, n_nodes); int16 on disk
+link = pd.read_parquet("data/link_telemetry", filters=[("episode_id", "=", eid), ("router", "=", "potential")]).sort_values("step")
+load = np.stack(link.load_uv).astype(np.int32) + np.stack(link.load_vu)   # (steps, n_edges), both directions
+field = pd.read_parquet("data/potential_field", filters=[("episode_id", "=", eid)]).sort_values("step")
+row = ep.loc[eid]
+phi = np.stack(field.potential).reshape(-1, row.tracked_flows, row.n_nodes)   # (snapshots, tracked flows, nodes)
+```
+
+The graph state at any step — the N × N capacity matrix in force — follows from `episodes` and `events`:
+
+```python
+def capacity_matrix(row, events, step):
+    cap = row.capacity.astype(float).copy()
+    factor, failed = np.ones(row.n_nodes), np.zeros(len(cap), bool)
+    for e in events[(events.start <= step) & (step < events.end)].itertuples():
+        if e.kind == "node_degradation":
+            factor[e.node] *= e.factor
+        else:
+            failed |= (row.edge_u == e.edge_u) & (row.edge_v == e.edge_v)
+    cap = np.maximum(1, np.floor(cap * factor[row.edge_u] * factor[row.edge_v]))
+    cap[failed] = 0
+    A = np.zeros((row.n_nodes, row.n_nodes))
+    A[row.edge_u, row.edge_v] = A[row.edge_v, row.edge_u] = cap
+    return A
+
+events = pd.read_parquet("data/events", filters=[("episode_id", "=", eid)])
+A = capacity_matrix(row, events, step=500)
+```
+
+The same reconstruction, the telemetry of any router and an exact recomputation of the field of any flow at
+any step are one call each in the read API:
+
+```python
+from src.dataset import Dataset
+
+ds = Dataset("data")
+ep = ds.episode(7)
+A = ep.capacity_matrix(500)                       # the graph state at step 500
+queue = ep.queue_depth("potential")               # (steps, n_nodes)
+phi = ep.solve_field(500, flows=[0, 1, 2])         # exact field of any flows at any step
+path = ep.descent_path(500, phi[0], ep.source[0], ep.sink[0])
+```
+
+`scripts/validate_dataset.py` checks such recomputations against the sparse SuperLU reference solver. From
+the Hub, each table is a configuration:
+
+```python
+from datasets import load_dataset
+rs = load_dataset("<user>/<dataset>", "router_summary", split="train")
+```
+
+Suggested uses: benchmarking routing policies on identical scenarios; forecasting queue build-up, drops
+or link saturation from step-level telemetry (`network_telemetry`, `link_telemetry`); learning graph
+surrogates of the potential field or of the routers' next-hop decisions (`potential_field` plus the graph
+state); studying route flapping of adaptive policies (`route_changes`); and out-of-distribution evaluation
+across topology families, sizes or dynamics levels using the factor columns of `episodes`.
+
+## Examples
+
+`examples/` holds four scripts written against the small read API in `src/dataset.py` — `Dataset(path)`
+opens a data folder, `ds.table(name, columns, filters)` and `ds.summary(name)` return tables (the latter
+joined with the design factors and split), and `ds.episode(id)` bundles one episode: its graph, event
+timeline and flows, the capacities in force at any step (`capacity_at`, `live_graph`, `capacity_matrix`),
+its telemetry under any router (`queue_depth`, `node_dropped`, `link_load`, `link_utilisation`), the stored
+field (`field`) and an exact recomputation of the field of *any* flow at *any* step (`solve_field`,
+`next_hops`, `descent_path`). Every script runs on `data/` by default (`--data` selects another folder),
+prints its results, asserts the properties it relies on and ends with "All checks passed", so the set also
+serves as a usage test of a generated dataset.
+
+```bat
+python examples/benchmark_routers.py        :: paired router comparison with bootstrap intervals, per factor
+python examples/inspect_episode.py --episode 7 --step 500
+python examples/forecast_congestion.py      :: ridge forecast of near-term loss on the splits
+python examples/visualize.py                :: eight figures into figures/
+```
+
+### `benchmark_routers.py` — paired router comparison
+
+Compares every router with a reference (`--reference`, default `shortest_path`) on the identical episodes:
+mean loss and delay differences with 95 % bootstrap confidence intervals, win and tie rates, the loss ratio
+broken down by each design factor, and flow-level path stretch, latency stretch and queueing delay.
+`--csv figures/benchmark.csv` writes the per-episode joined summary. Abridged output:
+
+```
+Paired differences to 'shortest_path' (negative = better; bootstrap 95 % CI over episodes):
+                        episodes  loss_diff  loss_ci_low  loss_ci_high  wins_loss  delay_diff  wins_delay
+router
+adaptive_shortest_path       675    -0.0770      -0.0863       -0.0681     0.4593     -0.8561      0.5837
+ecmp                         675    -0.0082      -0.0107       -0.0059     0.3096     -0.1613      0.5244
+potential                    675    -0.0685      -0.0766       -0.0601     0.4607      0.3886      0.3615
+potential_split              675    -0.0828      -0.0924       -0.0734     0.4637      2.6682      0.1630
+potential_static             675    -0.0409      -0.0472       -0.0352     0.4074      1.0377      0.1733
+
+Flow level (flows with at least one delivered packet):
+                        flows  lossless_share  path_stretch  latency_stretch  queueing_delay  p99_delay
+potential               38879          0.9174        1.2646           1.2213          0.2678    11.0834
+potential_split         38879          0.9505        1.4912           1.6238          0.1118    23.9248
+potential_static        38879          0.8506        1.4371           1.2912          0.5299    11.4198
+shortest_path           38879          0.7846        1.2540           1.0038          1.6477    11.1648
+ecmp                    38879          0.7945        1.2541           1.0038          1.5072    11.2295
+adaptive_shortest_path  38879          0.9359        1.1999           1.0494          0.2220     9.3849
+```
+
+Read it as: the potential routers and the adaptive baseline cut loss by 4–8 percentage points against
+shortest path; the multipath split trades 2.7 steps of extra delay and 49 % path stretch for the lowest
+loss of all; the win rates are below 0.5 only because at light load more than half the episode pairs are
+exact ties (`ties_loss`, printed in the full table). The numbers above come from the two-minute rehearsal
+run (675 size-32 episodes, 200 steps), so they are noisier and lossier than a full sweep — the *ordering*
+of the routers is what reproduces.
+
+### `inspect_episode.py` — one episode, checked against the physics
+
+Prints the design cell, graph, flows, event timeline and router summary; then, at one step, the capacities
+in force, the busiest buffers and links; recomputes the tracked flows' potential field from the graph state
+and queue depths and asserts it against the stored snapshot *and* the sparse reference solver; and follows
+one flow's steepest-current descent to its sink.
+
+```
+Episode 7 [barabasi_albert/32/poisson/heavy/moderate] 32 nodes, 87 links, 64 flows, 200 steps, split=train
+  degree min/mean/max 3/5.44/16, capacity 8-80 pkt/step, latency 1-10 steps, total directed capacity 7678 pkt/step
+  flows: 64 between 32 endpoints, offered load rho = 0.100, tracked flows 8, field stride 1
+
+Topology events (1):
+            kind  start  end  node  factor
+node_degradation     72  128     6  0.4374
+
+Step 100: 0 failed links, 9 links with reduced capacity, 87 live links
+  busiest buffers under potential: node 0: 256, node 4: 189, node 6: 142
+  [ok] potential field of the 8 tracked flows recomputed from graph state + queues (max rel dev 4.9e-08)
+  [ok] pseudo-inverse solution agrees with the sparse SuperLU solve for flow 0
+  [ok] steepest-current descent of flow 0 reaches its sink: 12 -> 1 -> 7 (2 hops, shortest possible 2);
+       potentials 0.4934 > 0.4433 > 0.0000
+```
+
+The last line is the loop-freedom guarantee made concrete: the potential decreases strictly along the path
+and the walk terminates at the sink.
+
+### `forecast_congestion.py` — a learning task on the splits
+
+Predicts the network's loss ratio over the next `--horizon` steps from the last `--window` steps of
+`network_telemetry`, normalised by `total_capacity` so all sizes share one feature scale, with a closed-form
+ridge regression tuned on validation and reported on test against a persistence baseline:
+
+```
+data/: router potential, window 10, horizon 10, stride 5
+  samples: train 14,985 (405 episodes), validation 4,995 (135), test 4,995 (135); features 52
+Ridge penalty chosen on validation: lambda = 0.0001 (validation RMSE 0.0270)
+                             MAE    RMSE      R2
+ridge (validation)        0.0096  0.0270  0.8405
+persistence (validation)  0.0091  0.0325  0.7689
+ridge (test)              0.0099  0.0268  0.8285
+persistence (test)        0.0096  0.0342  0.7215
+```
+
+As a squared-loss model the ridge wins on RMSE and R² while persistence keeps a marginally lower MAE on the
+many loss-free windows — a useful reminder to state the metric before claiming a win. The script asserts
+that the splits are disjoint by episode and that no feature is undefined.
+
+### `visualize.py` — the figure gallery
+
+Draws eight PNGs into `figures/` (`--out`) with one fixed palette in which every router keeps its hue.
+Select a subset with `--figures`, and steer the single-episode panels with `--episode` (default: a busy
+one), `--step`, `--flow`, `--routers` (default `potential,shortest_path`) and `--dpi`:
+
+```bat
+python examples/visualize.py --data data_small --figures potential_field,timeline --episode 12 --step 400
+```
+
+| File | Shows |
+|---|---|
+| `topologies.png` | one graph per family, link width scaled by capacity |
+| `benchmark.png` | loss and mean delay per router at each load level, 95 % bootstrap intervals |
+| `timeline.png` | one episode step by step under two routers, with bursts and topology events marked |
+| `queue_heatmap.png` | buffer occupancy of every node over time, same episode, two routers side by side |
+| `link_utilisation.png` | CCDF of per-link-step utilisation: how often links run near saturation, per router |
+| `potential_field.png` | the field of one flow on the graph, node size = buffer occupancy, with the steepest-current next hops and the descent path |
+| `delays.png` | flow-level p99 delay and path stretch per router |
+| `traffic_profiles.png` | offered packets of one flow under each of the three profiles |
+
+![Router benchmark](figures/benchmark.png)
+
+![Potential field](figures/potential_field.png)
+
+![Buffer occupancy](figures/queue_heatmap.png)
+
+![Episode timeline](figures/timeline.png)
+
+## Reproducibility and provenance
+
+Episode `e` draws every random quantity from `numpy.random.default_rng([seed, e])` in a fixed order and
+the routers are deterministic, so `scripts/validate_dataset.py` can re-simulate any episode and compare it
+bit for bit. The generator also avoids the two places where platforms usually disagree: shortest-path
+next hops are derived from Dijkstra *distances* (exact, because latencies and the quantised adaptive
+costs are integer-valued) with a fixed tie rule rather than from the solver's predecessor tie-breaking,
+and the potential routers resolve mathematically tied currents — common on symmetric fabrics — within a
+relative tolerance far above rounding noise. All twenty sample episodes generated during development were
+bit-identical under NumPy 1.26 / SciPy 1.11 and NumPy 2.4 / SciPy 1.17. `data/config.json` records the
+configuration and `data/manifest.json` the dataset version, library versions, platform, design coverage
+and table statistics of the shards present.
+
+## Limitations
+
+Traffic is open-loop (no TCP-like feedback), nodes have a single shared drop-tail buffer, all packets
+have the same size, time is discretised to 1 ms steps and capacities to whole packets per step, and the
+topologies are synthetic families rather than measured networks. Routing tables are recomputed
+instantaneously with global knowledge, which is an upper bound on what a distributed implementation can
+achieve. These choices keep the routers comparable and the episodes reproducible; they should be kept in
+mind when transferring conclusions to production networks.
+
+## Publishing
+
+Uploading is the one manual step. Draw the figures this card embeds, log in once with a write token, then
+push the project folder — Parquet shards, `config.json`, `manifest.json`, this dataset card with its
+figures, and the generator and example source — as a dataset repository; the upload is resumable and its
+bookkeeping lives in `.cache/`:
+
+```bat
+python examples/visualize.py
+hf auth login
+python scripts/push_to_huggingface.py --repo <user>/<dataset>
+```
+
+Add `--private` for a private repository. The `configs:` block at the top of this file makes every table
+browsable in the Dataset Viewer as soon as the upload finishes.
+
+## Repository layout
+
+```
+├── README.md                    dataset card and this guide
+├── requirements.txt
+├── .gitignore                   keeps generated data and caches out of git
+├── src/
+│   ├── design.py                factors, levels, episode �� cell / replicate / split
+│   ├── config.py                every knob of the generator, one frozen dataclass
+│   ├── graph_generator.py       five topology families, connectivity-preserving event timelines
+│   ├── physics_engine.py        Laplacian potential field, routing gradient, multipath spraying, baselines
+│   ├── simulation_loop.py       traffic, vectorised packet queueing, six routers, multiprocessing sweep
+│   ├── telemetry_logger.py      Parquet schemas, sharded resumable writing, manifest
+│   └── dataset.py               read API: tables, episodes, graph state and field at any step
+├── scripts/
+│   ├── run_local_sweep.py       generate (automatic, resumable)
+│   ├── validate_dataset.py      verify a generated dataset
+│   └── push_to_huggingface.py   publish (manual)
+├── examples/
+│   ├── benchmark_routers.py     paired router benchmark
+│   ├── inspect_episode.py       one episode end to end, checked against the physics
+│   ├── forecast_congestion.py   loss forecasting on the splits
+│   └── visualize.py             figure gallery
+├── figures/                     drawn by examples/visualize.py
+└── data/                        generated shards, one folder per table, plus config.json and manifest.json
+```
+
+## Changelog
+
+**2.0** — full factorial design over five topology families, four sizes, three traffic profiles, three
+offered-load levels and three dynamics levels with balanced replicates and 60/20/20 splits; six routers
+(three potential-field variants, three classical baselines); two flows per endpoint with log-normal rates
+and offered load defined relative to network capacity; potential fields via the Laplacian pseudo-inverse
+(exact, O(N·F) per step); per-link loads, per-node drops, queueing/propagation delay decomposition, route
+changes, network-level per-step totals; manifest with provenance and coverage; validation script.
+
+**1.0** — 1,000 Barabási–Albert episodes with four flows, potential field vs. shortest path, six tables.
+
+Tooling fixes since the 2.0 data release (the Parquet schemas and the generated data are unchanged, so no
+regeneration is needed): the cross-table invariant checks in `scripts/validate_dataset.py` now stream the
+shards into a dense per-group accumulator instead of loading `flow_telemetry` into pandas, which exhausted
+memory on the full dataset, and they report the first group that differs when a sum disagrees; the
+potential-field figure widens the int16 `queue_depth` before scaling it into marker sizes, which previously
+overflowed and hid the busiest nodes.
+
+## Design notes
+
+The original blueprint solved `L φ = b` on the full Laplacian, which is singular and only consistent when
+`b` sums to zero — a condition that congestion injections break. Grounding the sink removes the
+singularity, gives the sink its physical meaning as the well of the field and yields the loop-freedom
+guarantee above. Choosing the next hop by the largest current rather than the lowest neighbouring
+potential makes the decision conductance-aware, so a low-capacity or high-latency link is not chosen merely
+because its far end sits at a low potential. Telemetry is streamed straight to Parquet in atomic, resumable
+shards, which is what the Hub reads natively and makes a separate HDF5 staging layer unnecessary.

data/config.json

@@ -0,0 +1,59 @@
+{
+  "replicates": 10,
+  "topologies": [
+    "barabasi_albert",
+    "watts_strogatz",
+    "erdos_renyi",
+    "waxman",
+    "fat_tree"
+  ],
+  "sizes": [
+    32,
+    64,
+    128,
+    256
+  ],
+  "traffic_profiles": [
+    "poisson",
+    "microburst",
+    "sustained"
+  ],
+  "load_levels": [
+    "light",
+    "moderate",
+    "heavy"
+  ],
+  "dynamics_levels": [
+    "static",
+    "moderate",
+    "severe"
+  ],
+  "routers": [
+    "potential",
+    "potential_split",
+    "potential_static",
+    "shortest_path",
+    "ecmp",
+    "adaptive_shortest_path"
+  ],
+  "seed": 2026,
+  "shard_episodes": 40,
+  "field_budget_bytes": 1000000,
+  "steps": 1000,
+  "buffer_size": 256,
+  "mean_degree": 6,
+  "capacity_range": [
+    8,
+    80
+  ],
+  "latency_range": [
+    1,
+    10
+  ],
+  "fat_tree_capacity": 40,
+  "flows_per_endpoint": 2,
+  "tracked_flows": 8,
+  "source_injection": 1.0,
+  "background_injection": 0.5,
+  "congestion_gain": 2.0
+}

data/episodes/part-00072.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ecf052ed4ef92c24913089aa4c8dd998dbdffce6502fde45402f6e4ec098d89
+size 363288

data/episodes/part-00073.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b0c032d6863e6488d0507d315fc6262de9d736eb7965462a56b24037acee0197
+size 87814

data/episodes/part-00074.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:726738214f37ab900980a2afd1b7b650b38689a93b3c716b4f5f5cfae6c80148
+size 226545

data/episodes/part-00075.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05d42b81dfb83e1cc82c670ec7b2812e4c5f22acdc15e6feec9df72d6dfa3c63
+size 314892

data/episodes/part-00076.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:808734d31a2d4f7e4edeff5c7e1c06375f65c713f47d0b178f3b7072f2635f78
+size 135633

data/episodes/part-00077.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e2374f59da68f12225532e9b4886e49bce0948d1fec373f0f4550968bc1f54e
+size 395860

data/episodes/part-00078.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04a8d15e17408c3a06c981e2f75d1b5ca57c62605262847c69291f51f59feafc
+size 195735

data/episodes/part-00079.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:58a811bd11c0eac612f44e973e89b67e95fe9ff7cfaccdf9e30219049d31a26b
+size 125645

data/episodes/part-00080.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5f559e188882f1fe6c6088f07d6f8e97bfbf1c5e887446e5dd380e2d4cfa05de
+size 331317

data/episodes/part-00081.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12128b7d39d144e06a797e056cff02da8638cf2f227e562c7e90d6f230e329c8
+size 80533

data/episodes/part-00082.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6600ad65186a0b4b3898eefce9e5bb8954a430ae28a1491b009f31afbf6e4501
+size 194180

data/episodes/part-00083.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ade31f367023d9053cc593c8f199fffe4d8556fbeb6ecb36536bf9fd26aef7c
+size 340456

data/episodes/part-00084.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a820111a2584d259dbde72310472d690819f07ff54c9b7200cf56e3676e6cbee
+size 96209

data/episodes/part-00085.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1960d92c92ffc8ad59a548ccf07df8ee5ec92fd0e8d82477ef37e5da3b0017f4
+size 286165

data/episodes/part-00086.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12c1e209931a228d37f5c5fdee7297158c4907a5301c74958cdfa7f1c9fd5c3d
+size 220559

data/episodes/part-00087.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:efefb69c75589c27f9573071191bec474e9f2676c6266dda21bef519e9aa7f46
+size 146520

data/episodes/part-00088.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e9a43f4df12209ea0e467f3dfa63d59fe782567403d057068145b7e3f0132f06
+size 372537

data/episodes/part-00089.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a517559f8a28874b4effd956d599e87f5c7385777beef99c0192496d2cf0fffb
+size 132831

data/episodes/part-00090.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d49ecab2f7efc1bd1fbd344fca63c27ddcadeb1ecbfb1e44cbbed413f3542a99
+size 222785

data/episodes/part-00091.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:96e7b620ea35a41a2fb7ca83a12884111fe1bc7af6ab906055629b0b048dc549
+size 432232

data/episodes/part-00092.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f795ab76d4433cbb2dc1fa62c653ecdf545a68c9ae93fc770c51bc2b79d53688
+size 61897

data/episodes/part-00093.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f0176f2904390bc61556e813cbaecb84ac5e84858cf7c22a71e7e75890221522
+size 220585

data/episodes/part-00094.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1d8616c8ace06aec0a10b96bd74c12b327b2125dc45196ace43adc17eb7eace
+size 228291

data/episodes/part-00095.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:019ce64d5bd45027b6e26b3971e073f506690c8e4ac7b809c0aaffc9a0d59018
+size 127159

data/episodes/part-00096.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2bdd1d10035beac3facc20097a46ac2cea583e920309b5a7a97520aa02d5d818
+size 346484

data/episodes/part-00097.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ffcc878913bd21827348cfb00ef526ce28455011eeabf4a62940fba47b7745a
+size 150993

data/episodes/part-00098.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:71d30bb06c73e24de6f4c2a29899b9e904a476b902280058239810d9773b42ac
+size 168108

data/episodes/part-00099.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34528f8fead5135edf38157c1a0aedf3c2301c797cf9b85ff317690853ec133e
+size 363223

data/episodes/part-00100.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:42eeda03f6cca2abcf19fb7738c8b10d3d5786ee7f59b7c145bbdeddd94050dc
+size 87427

data/episodes/part-00101.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70572b9a8568e9617d4ed3e17bb060acee567b1035dfa049ef464a793f96f72b
+size 226256

data/manifest.json

@@ -0,0 +1,156 @@
+{
+  "dataset_version": "2.0",
+  "created_utc": "2026-08-30T03:43:51+00:00",
+  "provenance": {
+    "python": "3.14.7",
+    "platform": "Windows-11-10.0.26200-SP0",
+    "numpy": "2.5.2",
+    "scipy": "1.18.1",
+    "pyarrow": "25.0.1",
+    "pandas": "3.0.5",
+    "networkx": "3.6.1"
+  },
+  "config": {
+    "replicates": 10,
+    "topologies": [
+      "barabasi_albert",
+      "watts_strogatz",
+      "erdos_renyi",
+      "waxman",
+      "fat_tree"
+    ],
+    "sizes": [
+      32,
+      64,
+      128,
+      256
+    ],
+    "traffic_profiles": [
+      "poisson",
+      "microburst",
+      "sustained"
+    ],
+    "load_levels": [
+      "light",
+      "moderate",
+      "heavy"
+    ],
+    "dynamics_levels": [
+      "static",
+      "moderate",
+      "severe"
+    ],
+    "routers": [
+      "potential",
+      "potential_split",
+      "potential_static",
+      "shortest_path",
+      "ecmp",
+      "adaptive_shortest_path"
+    ],
+    "seed": 2026,
+    "shard_episodes": 40,
+    "field_budget_bytes": 1000000,
+    "steps": 1000,
+    "buffer_size": 256,
+    "mean_degree": 6,
+    "capacity_range": [
+      8,
+      80
+    ],
+    "latency_range": [
+      1,
+      10
+    ],
+    "fat_tree_capacity": 40,
+    "flows_per_endpoint": 2,
+    "tracked_flows": 8,
+    "source_injection": 1.0,
+    "background_injection": 0.5,
+    "congestion_gain": 2.0
+  },
+  "design": {
+    "cells": 540,
+    "episodes_planned": 5400,
+    "episodes_present": 5400,
+    "episodes_per_cell_min": 10,
+    "episodes_per_cell_max": 10
+  },
+  "coverage": {
+    "topology": {
+      "barabasi_albert": 1080,
+      "erdos_renyi": 1080,
+      "fat_tree": 1080,
+      "watts_strogatz": 1080,
+      "waxman": 1080
+    },
+    "size": {
+      "32": 1350,
+      "64": 1350,
+      "128": 1350,
+      "256": 1350
+    },
+    "traffic_profile": {
+      "microburst": 1800,
+      "poisson": 1800,
+      "sustained": 1800
+    },
+    "load_level": {
+      "heavy": 1800,
+      "light": 1800,
+      "moderate": 1800
+    },
+    "dynamics_level": {
+      "moderate": 1800,
+      "severe": 1800,
+      "static": 1800
+    },
+    "split": {
+      "test": 1080,
+      "train": 3240,
+      "validation": 1080
+    }
+  },
+  "tables": {
+    "episodes": {
+      "files": 135,
+      "rows": 5400,
+      "bytes": 30041631
+    },
+    "events": {
+      "files": 135,
+      "rows": 43246,
+      "bytes": 873246
+    },
+    "router_summary": {
+      "files": 135,
+      "rows": 32400,
+      "bytes": 1821131
+    },
+    "flow_summary": {
+      "files": 135,
+      "rows": 7672320,
+      "bytes": 188357615
+    },
+    "flow_telemetry": {
+      "files": 135,
+      "rows": 259200000,
+      "bytes": 959075231
+    },
+    "network_telemetry": {
+      "files": 135,
+      "rows": 32400000,
+      "bytes": 3687668325
+    },
+    "link_telemetry": {
+      "files": 135,
+      "rows": 32400000,
+      "bytes": 9272669204
+    },
+    "potential_field": {
+      "files": 135,
+      "rows": 1501470,
+      "bytes": 3481173416
+    }
+  }
+}

examples/benchmark_routers.py

@@ -0,0 +1,105 @@
+"""Benchmark the routers on identical scenarios.
+
+    python examples/benchmark_routers.py                       # data/
+    python examples/benchmark_routers.py --data data_small --reference potential --csv figures/benchmark.csv
+
+Every episode is replayed under every router, so the comparison is *paired*: for each router the
+script reports its per-episode difference to a reference router (loss ratio, mean delay) with a
+bootstrap 95 % confidence interval over episodes and the fraction of episodes it wins, then
+breaks the loss ratio down by each design factor and the flow-level path stretch and queueing
+delay. The script also asserts the structural properties the analysis relies on (every episode
+present under every router, aligned pairs), so it doubles as an end-to-end read test.
+"""
+import argparse
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from src.dataset import FACTORS, Dataset  # noqa: E402
+
+METRICS = ["loss_ratio", "mean_delay", "p99_delay", "link_utilisation", "link_saturation", "route_changes"]
+
+
+def bootstrap_ci(values: np.ndarray, rng: np.random.Generator, samples: int = 2000, level: float = 0.95):
+    """Percentile bootstrap confidence interval of the mean over episodes."""
+    means = rng.choice(values, size=(samples, len(values)), replace=True).mean(axis=1)
+    lo, hi = np.percentile(means, [50 * (1 - level), 50 * (1 + level)])
+    return values.mean(), lo, hi
+
+
+def paired_table(summary: pd.DataFrame, reference: str, rng: np.random.Generator) -> pd.DataFrame:
+    wide = {m: summary.pivot(index="episode_id", columns="router", values=m) for m in ("loss_ratio", "mean_delay")}
+    rows = []
+    for router in wide["loss_ratio"].columns:
+        if router == reference:
+            continue
+        d_loss = (wide["loss_ratio"][router] - wide["loss_ratio"][reference]).to_numpy()
+        pair = wide["mean_delay"][[router, reference]].dropna()   # NaN delay only if nothing was delivered
+        d_delay = (pair[router] - pair[reference]).to_numpy()
+        m, lo, hi = bootstrap_ci(d_loss, rng)
+        md, dlo, dhi = bootstrap_ci(d_delay, rng)
+        rows.append({"router": router, "episodes": len(d_loss),
+                     "loss_diff": m, "loss_ci_low": lo, "loss_ci_high": hi,
+                     "wins_loss": np.mean(d_loss < 0), "ties_loss": np.mean(d_loss == 0),
+                     "delay_diff": md, "delay_ci_low": dlo, "delay_ci_high": dhi,
+                     "wins_delay": np.mean(d_delay < 0)})
+    return pd.DataFrame(rows).set_index("router")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--data", type=Path, default=ROOT / "data", help="dataset folder (default: data/)")
+    parser.add_argument("--reference", default="shortest_path", help="router the others are compared with")
+    parser.add_argument("--csv", type=Path, default=None, help="write the per-episode joined summary here")
+    parser.add_argument("--seed", type=int, default=0, help="bootstrap seed")
+    args = parser.parse_args()
+    pd.set_option("display.width", 160)
+    pd.set_option("display.precision", 4)
+
+    ds = Dataset(args.data)
+    summary = ds.summary("router_summary")
+    routers = list(ds.routers)
+    assert set(summary.router) == set(routers), "router_summary does not contain every configured router"
+    per_episode = summary.groupby("episode_id").router.nunique()
+    assert (per_episode == len(routers)).all(), "every episode must be present under every router"
+    assert args.reference in routers, f"--reference must be one of {routers}"
+    print(f"{ds.path}: {summary.episode_id.nunique()} episodes x {len(routers)} routers, "
+          f"{len(ds.config.cells)} design cells\n")
+
+    print("Mean over episodes:")
+    print(summary.groupby("router")[METRICS].mean().loc[routers].to_string(), "\n")
+
+    print(f"Paired differences to '{args.reference}' (negative = better; bootstrap 95 % CI over episodes):")
+    print(paired_table(summary, args.reference, np.random.default_rng(args.seed)).to_string(), "\n")
+
+    for factor in FACTORS:
+        if summary[factor].nunique() > 1:
+            print(f"Mean loss ratio by {factor}:")
+            print(summary.pivot_table(index=factor, columns="router", values="loss_ratio", aggfunc="mean")[routers]
+                  .to_string(), "\n")
+
+    flows = ds.summary("flow_summary")
+    delivered = flows[flows.delivered > 0].copy()
+    delivered["path_stretch"] = delivered.mean_hops / delivered.min_hops
+    delivered["latency_stretch"] = delivered.mean_path_latency / delivered.min_latency
+    print("Flow level (flows with at least one delivered packet):")
+    print(delivered.groupby("router").agg(flows=("flow", "size"), lossless_share=("dropped", lambda d: np.mean(d == 0)),
+                                           path_stretch=("path_stretch", "mean"),
+                                           latency_stretch=("latency_stretch", "mean"),
+                                           queueing_delay=("mean_queueing_delay", "mean"),
+                                           p99_delay=("p99_delay", "mean")).loc[routers].to_string(), "\n")
+
+    if args.csv:
+        args.csv.parent.mkdir(parents=True, exist_ok=True)
+        summary.to_csv(args.csv, index=False)
+        print(f"Per-episode summary written to {args.csv}")
+    print("All checks passed.")
+
+
+if __name__ == "__main__":
+    main()

examples/forecast_congestion.py

@@ -0,0 +1,138 @@
+"""Forecast near-term packet loss from step-level telemetry: a learning example on the splits.
+
+    python examples/forecast_congestion.py                             # data/, potential router
+    python examples/forecast_congestion.py --router shortest_path --window 20 --horizon 20 --stride 10
+
+Task: at step t, predict the network's loss ratio over the next `horizon` steps (dropped / offered)
+from the last `window` steps of the network totals in ``network_telemetry`` (offered, delivered,
+dropped, queued, in transit), normalised by the episode's total capacity so that networks of
+different sizes share one feature scale, plus the recent loss ratio itself. A ridge regression (closed form, NumPy only) is fitted
+on the train split, its penalty chosen on the validation split, and reported on the test split
+against a persistence baseline (the loss ratio of the preceding `horizon` steps). The script
+asserts that the splits are disjoint by episode and that no feature is undefined.
+"""
+import argparse
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from numpy.lib.stride_tricks import sliding_window_view
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from src.dataset import Dataset  # noqa: E402
+
+CHANNELS = ("offered", "delivered", "dropped", "queued", "in_transit")
+
+
+def windows(frame: pd.DataFrame, capacity: float, n_nodes: int, window: int, horizon: int, stride: int):
+    """Feature matrix, target, baseline and step index for one episode's step series."""
+    series = frame[list(CHANNELS)].to_numpy(np.float64)
+    steps = len(series)
+    t = np.arange(max(window, horizon), steps - horizon + 1, stride)
+    if len(t) == 0:
+        return None
+    past = sliding_window_view(series, window, axis=0)[t - window]                # (samples, channels, window)
+    future = sliding_window_view(series[:, :3], horizon, axis=0)[t]                # offered, delivered, dropped
+    offered_next, dropped_next = future[:, 0].sum(1), future[:, 2].sum(1)
+    recent = sliding_window_view(series[:, :3], horizon, axis=0)[t - horizon]
+    keep = offered_next > 0                                                         # loss ratio well defined
+    with np.errstate(invalid="ignore", divide="ignore"):
+        baseline = np.where(recent[:, 0].sum(1) > 0, recent[:, 2].sum(1) / recent[:, 0].sum(1), 0.0)
+    features = np.concatenate([past.reshape(len(t), -1) / capacity, baseline[:, None],
+                               np.full((len(t), 1), np.log10(n_nodes))], axis=1)
+    target = dropped_next / np.maximum(offered_next, 1)
+    return features[keep], target[keep], baseline[keep], t[keep]
+
+
+def ridge_fit(x: np.ndarray, y: np.ndarray, lam: float) -> np.ndarray:
+    n, d = x.shape
+    return np.linalg.solve(x.T @ x / n + lam * np.eye(d), x.T @ y / n)
+
+
+def metrics(y: np.ndarray, pred: np.ndarray) -> dict:
+    pred = np.clip(pred, 0.0, 1.0)
+    sse = np.sum((y - pred) ** 2)
+    return {"MAE": np.mean(np.abs(y - pred)), "RMSE": np.sqrt(sse / len(y)),
+            "R2": 1.0 - sse / max(np.sum((y - y.mean()) ** 2), 1e-12)}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--data", type=Path, default=ROOT / "data", help="dataset folder (default: data/)")
+    parser.add_argument("--router", default="potential")
+    parser.add_argument("--window", type=int, default=10, help="steps of history used as features")
+    parser.add_argument("--horizon", type=int, default=10, help="steps ahead over which loss is predicted")
+    parser.add_argument("--stride", type=int, default=5, help="steps between consecutive samples")
+    parser.add_argument("--max-episodes", type=int, default=0, help="cap on episodes (0 = all)")
+    args = parser.parse_args()
+    pd.set_option("display.width", 160)
+    pd.set_option("display.precision", 4)
+
+    ds = Dataset(args.data)
+    episodes = ds.episodes
+    if args.max_episodes:
+        episodes = episodes.iloc[: args.max_episodes]
+    if episodes.split.nunique() < 3:   # fewer than five replicates: fall back to a split by episode id
+        fallback = np.array(["train", "train", "train", "validation", "test"])[episodes.index % 5]
+        episodes = episodes.assign(split=fallback)
+        print("note: the dataset has no validation/test replicates; splitting by episode id modulo 5 instead")
+    net = ds.table("network_telemetry", columns=["episode_id", "step"] + list(CHANNELS),
+                   filters=[("router", "=", args.router)])
+    net = net[net.episode_id.isin(episodes.index)].sort_values(["episode_id", "step"])
+
+    parts = {"train": [], "validation": [], "test": []}
+    seen = {s: set() for s in parts}
+    for eid, frame in net.groupby("episode_id", sort=False):
+        row = episodes.loc[eid]
+        sample = windows(frame, float(row.total_capacity), int(row.n_nodes), args.window, args.horizon, args.stride)
+        if sample is not None:
+            parts[row.split].append((eid, *sample))
+            seen[row.split].add(eid)
+    assert not (seen["train"] & seen["test"]) and not (seen["train"] & seen["validation"]), "splits overlap"
+    assert all(parts.values()), "every split needs episodes: " + ", ".join(f"{k} {len(v)}" for k, v in parts.items())
+
+    def stack(split):
+        x = np.concatenate([p[1] for p in parts[split]])
+        y = np.concatenate([p[2] for p in parts[split]])
+        b = np.concatenate([p[3] for p in parts[split]])
+        eids = np.concatenate([np.full(len(p[2]), p[0]) for p in parts[split]])
+        return x, y, b, eids
+
+    x_tr, y_tr, _, _ = stack("train")
+    x_va, y_va, b_va, _ = stack("validation")
+    x_te, y_te, b_te, e_te = stack("test")
+    assert np.isfinite(x_tr).all() and np.isfinite(x_va).all() and np.isfinite(x_te).all()
+    mean, std = x_tr.mean(0), x_tr.std(0) + 1e-12
+    z = lambda x: np.hstack([(x - mean) / std, np.ones((len(x), 1))])  # noqa: E731  standardise + intercept
+    print(f"{ds.path}: router {args.router}, window {args.window}, horizon {args.horizon}, stride {args.stride}")
+    print(f"  samples: train {len(y_tr):,} ({len(seen['train'])} episodes), validation {len(y_va):,} "
+          f"({len(seen['validation'])}), test {len(y_te):,} ({len(seen['test'])}); features {x_tr.shape[1]}")
+    print(f"  target: loss ratio over the next {args.horizon} steps; mean {y_tr.mean():.4f}, "
+          f"share of samples with loss {np.mean(y_tr > 0):.3f}")
+
+    grid = [10 ** k for k in range(-6, 3)]
+    scores = {lam: metrics(y_va, z(x_va) @ ridge_fit(z(x_tr), y_tr, lam))["RMSE"] for lam in grid}
+    lam = min(scores, key=scores.get)
+    w = ridge_fit(z(x_tr), y_tr, lam)
+    print(f"\nRidge penalty chosen on validation: lambda = {lam:g} (validation RMSE {scores[lam]:.4f})")
+    report = pd.DataFrame({"ridge (validation)": metrics(y_va, z(x_va) @ w),
+                           "persistence (validation)": metrics(y_va, b_va),
+                           "ridge (test)": metrics(y_te, z(x_te) @ w),
+                           "persistence (test)": metrics(y_te, b_te)}).T
+    print(report.to_string())
+
+    test_pred = np.clip(z(x_te) @ w, 0, 1)
+    by_load = pd.DataFrame({"episode_id": e_te, "ridge_error": np.abs(y_te - test_pred),
+                            "persistence_error": np.abs(y_te - b_te), "target": y_te})
+    by_load = by_load.join(episodes[["load_level", "traffic_profile"]], on="episode_id")
+    print("\nTest MAE by load level and traffic profile:")
+    print(by_load.groupby(["load_level", "traffic_profile"])[["target", "ridge_error", "persistence_error"]]
+          .mean().rename(columns={"target": "mean_loss"}).to_string())
+    print("\nAll checks passed.")
+
+
+if __name__ == "__main__":
+    main()

examples/inspect_episode.py

@@ -0,0 +1,105 @@
+"""Walk through one episode with the ``Dataset`` API and check it against the physics.
+
+    python examples/inspect_episode.py                        # episode 0 of data/
+    python examples/inspect_episode.py --data data_small --episode 7 --step 500 --router potential
+
+Prints the design cell, the graph, the flows, the event timeline and the router summary; then,
+at one step, the capacities in force, the busiest buffers and links; recomputes the potential
+field of the tracked flows from the graph state and queue depths and compares it with the stored
+snapshot; and follows the steepest-current descent of a tracked flow from its source to its sink.
+Every comparison is asserted, so the script is also a test of the relational tables.
+"""
+import argparse
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from src.dataset import Dataset  # noqa: E402
+from src.physics_engine import grounded_solve  # noqa: E402
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--data", type=Path, default=ROOT / "data", help="dataset folder (default: data/)")
+    parser.add_argument("--episode", type=int, default=0)
+    parser.add_argument("--step", type=int, default=500, help="step to inspect (snapped to a logged field step)")
+    parser.add_argument("--router", default="potential", help="router whose telemetry is shown")
+    args = parser.parse_args()
+    pd.set_option("display.width", 160)
+
+    ds = Dataset(args.data)
+    ep = ds.episode(args.episode)
+    print(ep)
+    degree = np.bincount(ep.edges.ravel(), minlength=ep.n_nodes)
+    print(f"  degree min/mean/max {degree.min()}/{degree.mean():.2f}/{degree.max()}, "
+          f"capacity {ep.capacity.min()}-{ep.capacity.max()} pkt/step, latency {ep.latency.min()}-{ep.latency.max()} steps, "
+          f"total directed capacity {ep.row.total_capacity:.0f} pkt/step")
+    rates = np.asarray(ep.row.flow_mean_rate)
+    print(f"  flows: {ep.n_flows} between {len(ep.topology.endpoints)} endpoints, offered load rho = {ep.row.offered_load:.3f}, "
+          f"mean rate min/median/max {rates.min():.2f}/{np.median(rates):.2f}/{rates.max():.2f} pkt/step, "
+          f"tracked flows {ep.tracked_flows}, field stride {ep.field_stride}")
+
+    print(f"\nTopology events ({len(ep.events)}):")
+    if len(ep.events):
+        print(ep.events[["kind", "start", "end", "node", "edge_u", "edge_v", "factor"]].to_string(index=False))
+    else:
+        print("  none (static dynamics level)")
+
+    print("\nRouter summary:")
+    summary = ep.telemetry("router_summary").set_index("router")
+    print(summary[["loss_ratio", "mean_delay", "p99_delay", "mean_queue", "max_queue",
+                   "link_utilisation", "link_saturation", "route_changes"]].to_string())
+    flows = ep.telemetry("flow_summary")
+    assert (flows.offered == flows.delivered + flows.dropped + flows.in_flight).all()
+    print("  [ok] packet conservation holds for every flow and router")
+
+    step = ep.nearest_logged_step(args.step)
+    cap = ep.capacity_at(step)
+    failed, degraded = int((cap == 0).sum()), int((cap < ep.capacity).sum() - (cap == 0).sum())
+    print(f"\nStep {step} (nearest logged field step to {args.step}): {failed} failed links, "
+          f"{degraded} links with reduced capacity, {len(ep.live_graph(step).src) // 2} live links")
+    queue = ep.queue_depth(args.router)[step]
+    busiest = np.argsort(-queue)[:5]
+    print(f"  busiest buffers under {args.router}: " + ", ".join(f"node {i}: {queue[i]}" for i in busiest))
+    util = ep.link_utilisation(args.router)[step]
+    flat = np.nan_to_num(util, nan=-1).ravel()
+    top = np.argsort(-flat)[:5]
+    print("  most utilised directed links: " + ", ".join(
+        f"{ep.edges[k // 2, k % 2]}->{ep.edges[k // 2, 1 - k % 2]}: {flat[k]:.0%}" for k in top))
+
+    stored = ep.field(step)
+    queue_potential = ep.queue_depth("potential")[step]          # the field responds to its own router's buffers
+    recomputed = ep.solve_field(step, queue_potential)
+    rel = np.abs(recomputed - stored).max() / np.abs(stored).max()
+    assert rel < 1e-5, rel
+    print(f"  [ok] potential field of the {ep.tracked_flows} tracked flows recomputed from graph state + queues "
+          f"(max relative deviation from the stored float32 snapshot {rel:.1e})")
+    g = ep.live_graph(step)
+    b = (ep.config.background_injection / (ep.n_nodes - 1)
+         + ep.config.congestion_gain * queue_potential.astype(np.float64) / ep.config.buffer_size)
+    b[ep.source[0]] += ep.config.source_injection
+    reference = grounded_solve(g, int(ep.sink[0]), b)
+    assert np.abs(reference - recomputed[0]).max() < 1e-9 * max(1.0, np.abs(reference).max())
+    print("  [ok] pseudo-inverse solution agrees with the sparse SuperLU solve for flow 0")
+
+    s, t = int(ep.source[0]), int(ep.sink[0])
+    path = ep.descent_path(step, recomputed[0], s, t)
+    phi = recomputed[0][path]
+    assert path[0] == s and path[-1] == t and np.all(np.diff(phi) < 0) and len(path) <= ep.n_nodes
+    print(f"  [ok] steepest-current descent of flow 0 reaches its sink: {' -> '.join(map(str, path))} "
+          f"({len(path) - 1} hops, shortest possible {int(flows.min_hops.iloc[0])}); potentials "
+          + " > ".join(f"{p:.4f}" for p in phi))
+    tracked = flows[(flows.router == args.router) & (flows.flow < ep.tracked_flows)]
+    print(f"\nTracked flows under {args.router}:")
+    print(tracked[["flow", "source", "sink", "mean_rate", "min_hops", "offered", "delivered", "dropped",
+                   "loss_ratio", "mean_delay", "mean_queueing_delay", "mean_hops", "route_changes"]].to_string(index=False))
+    print("\nAll checks passed.")
+
+
+if __name__ == "__main__":
+    main()

examples/visualize.py

@@ -0,0 +1,372 @@
+"""Figure gallery for a generated dataset (matplotlib, PNG).
+
+    python examples/visualize.py                                   # every figure from data/ into figures/
+    python examples/visualize.py --data data_small --figures potential_field,timeline --episode 12 --step 400
+
+Figures: `topologies` (one graph per family, links scaled by capacity), `benchmark` (loss and
+delay per router by offered load, with 95 % bootstrap intervals), `timeline` (one episode step by
+step under two routers, with bursts and topology events), `queue_heatmap` (buffer occupancy of
+every node over time, same episode, two routers), `link_utilisation` (how often links run near
+saturation, per router), `potential_field` (the field of one flow on the graph with the
+steepest-current next hops and the descent path), `delays` (flow-level p99 delay and path stretch
+per router) and `traffic_profiles` (offered packets of one flow under each profile). Colours
+follow one fixed palette: every router keeps its hue in every figure.
+"""
+import argparse
+import sys
+from pathlib import Path
+
+import matplotlib
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+from matplotlib.collections import LineCollection
+from matplotlib.colors import LinearSegmentedColormap, Normalize
+from matplotlib.ticker import FuncFormatter, MaxNLocator
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from src.config import ROUTERS  # noqa: E402
+from src.dataset import Dataset, Episode  # noqa: E402
+from src.design import LOAD_LEVELS, TRAFFIC_PROFILES  # noqa: E402
+
+matplotlib.use("Agg")
+
+SERIES = ["#2a78d6", "#eb6834", "#1baf7a", "#eda100", "#e87ba4", "#008300"]   # categorical slots 1-6
+ROUTER_COLOR = dict(zip(ROUTERS, SERIES))
+BLUES = LinearSegmentedColormap.from_list("sequential", ["#cde2fb", "#9ec5f4", "#6da7ec", "#3987e5",
+                                                          "#256abf", "#184f95", "#0d366b"])
+ACCENT, SURFACE, INK, INK2, MUTED, GRID, ALERT = "#eb6834", "#fcfcfb", "#0b0b0b", "#52514e", "#a09f9a", "#e6e5e1", "#e34948"
+FIGURES = ("topologies", "benchmark", "timeline", "queue_heatmap", "link_utilisation",
+           "potential_field", "delays", "traffic_profiles")
+LABEL = {"potential": "potential", "potential_split": "potential split", "potential_static": "potential static",
+         "shortest_path": "shortest path", "ecmp": "ECMP", "adaptive_shortest_path": "adaptive shortest path"}
+
+
+def style() -> None:
+    plt.rcParams.update({
+        "figure.facecolor": SURFACE, "axes.facecolor": SURFACE, "savefig.facecolor": SURFACE,
+        "font.size": 9, "axes.titlesize": 10, "axes.labelsize": 9, "axes.titleweight": "medium",
+        "text.color": INK, "axes.labelcolor": INK2, "xtick.color": INK2, "ytick.color": INK2,
+        "axes.edgecolor": GRID, "axes.spines.top": False, "axes.spines.right": False,
+        "axes.grid": True, "grid.color": GRID, "grid.linewidth": 0.6, "axes.axisbelow": True,
+        "xtick.major.size": 0, "ytick.major.size": 0, "legend.frameon": False, "legend.fontsize": 8,
+        "lines.linewidth": 1.6,
+    })
+
+
+def save(fig, out: Path, name: str, dpi: int) -> None:
+    out.mkdir(parents=True, exist_ok=True)
+    path = out / f"{name}.png"
+    fig.savefig(path, dpi=dpi, bbox_inches="tight")
+    plt.close(fig)
+    print(f"  wrote {path}")
+
+
+def bootstrap_ci(values: np.ndarray, rng: np.random.Generator, samples: int = 2000):
+    means = rng.choice(values, size=(samples, len(values)), replace=True).mean(axis=1)
+    return np.percentile(means, [2.5, 97.5])
+
+
+def layout(ep: Episode) -> np.ndarray:
+    """Node positions: true coordinates (Waxman), tiers (fat-tree) or a seeded spring layout."""
+    if len(ep.node_xy):
+        return ep.node_xy.astype(float)
+    if ep.node_role.max() > 0:
+        tier = {1: 3.0, 2: 2.0, 3: 1.0, 4: 0.0}
+        pos = np.zeros((ep.n_nodes, 2))
+        for role, y in tier.items():
+            members = np.flatnonzero(ep.node_role == role)
+            pos[members, 0] = (np.arange(len(members)) + 0.5) / len(members)
+            pos[members, 1] = y / 3.0
+        return pos
+    graph = nx.Graph()
+    graph.add_nodes_from(range(ep.n_nodes))
+    graph.add_edges_from(ep.edges.tolist())
+    spring = nx.spring_layout(graph, seed=0)
+    return np.array([spring[i] for i in range(ep.n_nodes)])
+
+
+def draw_links(ax, ep: Episode, pos: np.ndarray, capacity: np.ndarray, base: np.ndarray) -> None:
+    live = capacity > 0
+    width = 0.3 + 1.7 * base[live] / base.max()
+    ax.add_collection(LineCollection(pos[ep.edges[live]], linewidths=width, colors=MUTED, alpha=0.55, zorder=1))
+    if (~live).any():
+        ax.add_collection(LineCollection(pos[ep.edges[~live]], linewidths=1.0, colors=ALERT,
+                                         linestyles=(0, (2, 2)), zorder=1, label="failed link"))
+
+
+def clean_axes(ax) -> None:
+    ax.set_xticks([])
+    ax.set_yticks([])
+    ax.grid(False)
+    for side in ("left", "bottom"):
+        ax.spines[side].set_visible(False)
+    ax.set_aspect("equal", adjustable="datalim")
+    ax.set_box_aspect(1)
+    ax.margins(0.05)
+
+
+def fig_topologies(ds: Dataset, out: Path, dpi: int, **_) -> None:
+    episodes = ds.episodes
+    picks = episodes.sort_values("n_nodes").groupby("topology", sort=False).head(1)
+    fig, axes = plt.subplots(1, len(picks), figsize=(3.4 * len(picks), 3.4))
+    for ax, (eid, row) in zip(np.atleast_1d(axes), picks.iterrows()):
+        ep = ds.episode(eid)
+        pos = layout(ep)
+        draw_links(ax, ep, pos, ep.capacity, ep.capacity)
+        if ep.node_role.max() > 0:
+            colours = [BLUES(0.85 - 0.22 * (r - 1)) for r in ep.node_role]
+        else:
+            colours = SERIES[0]
+        ax.scatter(pos[:, 0], pos[:, 1], s=16, c=colours, edgecolors=SURFACE, linewidths=0.6, zorder=3)
+        clean_axes(ax)
+        ax.set_title(f"{row.topology.replace('_', ' ')}\n{ep.n_nodes} nodes, {ep.n_edges} links, "
+                     f"mean degree {2 * ep.n_edges / ep.n_nodes:.1f}")
+    fig.suptitle("Topology families (link width proportional to capacity; fat-tree tiers core to hosts, dark to light)", y=1.02)
+    save(fig, out, "topologies", dpi)
+
+
+def fig_benchmark(ds: Dataset, out: Path, dpi: int, seed: int, **_) -> None:
+    summary = ds.summary("router_summary")
+    loads = [l for l in LOAD_LEVELS if l in set(summary.load_level)]
+    routers = [r for r in ROUTERS if r in set(summary.router)]
+    rng = np.random.default_rng(seed)
+    metrics = [("loss_ratio", "loss ratio"), ("mean_delay", "mean end-to-end delay (steps)")]
+    fig, axes = plt.subplots(len(metrics), len(loads), figsize=(3.6 * len(loads), 2.6 * len(metrics)),
+                             sharey=True, squeeze=False)
+    for i, (metric, label) in enumerate(metrics):
+        for j, load in enumerate(loads):
+            ax = axes[i, j]
+            sub = summary[summary.load_level == load]
+            for k, router in enumerate(routers):
+                values = sub[sub.router == router][metric].dropna().to_numpy()
+                mean = values.mean()
+                lo, hi = bootstrap_ci(values, rng)
+                y = len(routers) - 1 - k                                   # first router on top
+                ax.barh(y, mean, height=0.72, color=ROUTER_COLOR[router], zorder=2)
+                ax.errorbar(mean, y, xerr=[[mean - lo], [hi - mean]], fmt="none", ecolor=INK2, elinewidth=0.8, capsize=2, zorder=3)
+            ax.set_yticks(range(len(routers)))
+            ax.set_yticklabels([LABEL[r] for r in reversed(routers)])
+            ax.grid(axis="y", visible=False)
+            if i == 0:
+                ax.set_title(f"{load} load ({sub.episode_id.nunique()} episodes)")
+            ax.set_xlabel(label)
+            ax.set_xlim(left=0)
+            ax.xaxis.set_major_locator(MaxNLocator(4))
+            if metric == "loss_ratio":
+                ax.xaxis.set_major_formatter(FuncFormatter(lambda x, _: f"{100 * x:g}%"))
+    fig.suptitle("Router benchmark by offered load: mean over episodes with 95 % bootstrap intervals", y=1.01)
+    fig.tight_layout()
+    save(fig, out, "benchmark", dpi)
+
+
+def bursting_flows(ep: Episode) -> np.ndarray:
+    """Number of tracked flows in the burst state at every step."""
+    flows = ep.telemetry("flow_telemetry", ep.dataset.routers[0], ["episode_id", "router", "step", "flow", "mmpp_state"])
+    return flows.groupby("step").mmpp_state.sum().reindex(range(ep.steps), fill_value=0).to_numpy()
+
+
+def shade_bursts(ax, mask: np.ndarray) -> None:
+    edges = np.flatnonzero(np.diff(np.r_[0, mask.astype(int), 0]))
+    for start, end in zip(edges[::2], edges[1::2]):
+        ax.axvspan(start, end, color=INK2, alpha=0.08, linewidth=0, zorder=0)
+
+
+def mark_events(ax, ep: Episode) -> None:
+    for e in ep.events.itertuples():
+        ax.axvline(e.start, color=ALERT if e.kind == "link_failure" else MUTED, linewidth=0.8, zorder=1)
+
+
+def fig_timeline(ds: Dataset, out: Path, dpi: int, episode: int, routers, **_) -> None:
+    ep = ds.episode(episode)
+    frames = {r: ep.telemetry("network_telemetry", r, ["episode_id", "router", "step", "offered", "delivered",
+                                                       "dropped", "queued", "route_changes"]) for r in routers}
+    bursts = bursting_flows(ep)
+    fig, axes = plt.subplots(5, 1, figsize=(10, 8.2), sharex=True, gridspec_kw={"height_ratios": [1, 3, 3, 3, 3]})
+    axes[0].fill_between(np.arange(ep.steps), bursts, step="mid", color=INK2, alpha=0.35, linewidth=0)
+    axes[0].set_ylabel(f"tracked flows\nin burst (of {ep.tracked_flows})", fontsize=8)
+    axes[0].set_ylim(0, max(1, bursts.max()))
+    axes[0].yaxis.set_major_locator(MaxNLocator(integer=True, nbins=3))
+    panels = [("delivered", "delivered\n(packets / step)"), ("dropped", "dropped\n(packets / step)"),
+              ("queued", "waiting in buffers\n(packets)"), ("route_changes", "next-hop changes\n(per step)")]
+    for ax, (column, label) in zip(axes[1:], panels):
+        if column == "delivered":
+            ax.plot(frames[routers[0]].step, frames[routers[0]].offered, color=MUTED, linewidth=1.0, label="offered")
+        for r in routers:
+            ax.plot(frames[r].step, frames[r][column], color=ROUTER_COLOR[r], label=LABEL[r])
+        ax.set_ylabel(label, fontsize=8)
+        ax.set_ylim(bottom=0)
+    for ax in axes:
+        mark_events(ax, ep)
+    axes[4].set_yscale("symlog", linthresh=10)
+    axes[4].set_xlabel("step (1 step = 1 ms)")
+    axes[1].legend(loc="upper right", ncol=3)
+    summary = ep.telemetry("router_summary").set_index("router")
+    losses = ", ".join(f"{LABEL[r]} loss {summary.loss_ratio[r]:.1%}" for r in routers)
+    fig.suptitle(f"Episode {ep.id} ({'/'.join(str(v) for v in ep.cell.values())}): {losses}\n"
+                 f"vertical lines: link failure (red) or node degradation (grey) begins", fontsize=9)
+    fig.align_ylabels(axes)
+    save(fig, out, "timeline", dpi)
+
+
+def fig_queue_heatmap(ds: Dataset, out: Path, dpi: int, episode: int, routers, **_) -> None:
+    ep = ds.episode(episode)
+    queues = {r: ep.queue_depth(r) for r in routers}
+    order = np.argsort(-queues[routers[-1]].mean(0))                      # same node order in every panel
+    vmax = max(q.max() for q in queues.values())
+    fig, axes = plt.subplots(1, len(routers), figsize=(5.2 * len(routers), 4.2), sharey=True)
+    summary = ep.telemetry("router_summary").set_index("router")
+    for ax, r in zip(np.atleast_1d(axes), routers):
+        image = ax.imshow(queues[r][:, order].T, aspect="auto", cmap=BLUES, vmin=0, vmax=vmax,
+                          interpolation="nearest", origin="upper")
+        ax.set_title(f"{LABEL[r]}: loss {summary.loss_ratio[r]:.1%}, mean occupancy {summary.mean_queue[r]:.1f}")
+        ax.set_xlabel("step (1 step = 1 ms)")
+        ax.grid(False)
+    np.atleast_1d(axes)[0].set_ylabel(f"node rank by mean occupancy under {LABEL[routers[-1]]} (busiest first)")
+    fig.colorbar(image, ax=list(np.atleast_1d(axes)), label=f"packets in buffer (capacity {ds.config.buffer_size})", shrink=0.9)
+    fig.suptitle(f"Buffer occupancy, episode {ep.id} ({'/'.join(str(v) for v in ep.cell.values())})", y=0.98)
+    save(fig, out, "queue_heatmap", dpi)
+
+
+def fig_link_utilisation(ds: Dataset, out: Path, dpi: int, episode: int, **_) -> None:
+    ep = ds.episode(episode)
+    fig, ax = plt.subplots(figsize=(6.4, 4))
+    grid = np.linspace(0, 1, 101)
+    for r in [r for r in ROUTERS if r in ds.routers]:
+        util = ep.link_utilisation(r)
+        util = util[np.isfinite(util)]
+        ccdf = [(util >= x).mean() for x in grid]
+        ax.plot(grid, ccdf, color=ROUTER_COLOR[r], label=LABEL[r])
+    ax.set_yscale("log")
+    ax.set_xlabel("utilisation of a directed link in one step (packets forwarded / capacity in force)")
+    ax.set_ylabel("share of link-steps at or above this utilisation")
+    ax.set_xlim(0, 1)
+    ax.legend(loc="lower left")
+    ax.set_title(f"How often links run near saturation, episode {ep.id} ({'/'.join(str(v) for v in ep.cell.values())})")
+    save(fig, out, "link_utilisation", dpi)
+
+
+def fig_potential_field(ds: Dataset, out: Path, dpi: int, episode: int, step: int, flow: int, **_) -> None:
+    ep = ds.episode(episode)
+    step = ep.nearest_logged_step(step)
+    phi = ep.field(step)[flow]
+    queue = ep.queue_depth("potential")[step].astype(np.float64)   # int16 telemetry: widen before scaling
+    pos = layout(ep)
+    source, sink = int(ep.source[flow]), int(ep.sink[flow])
+    hops = ep.next_hops(step, phi[None, :])[0]
+    path = ep.descent_path(step, phi, source, sink)
+    fig, ax = plt.subplots(figsize=(8.5, 7))
+    draw_links(ax, ep, pos, ep.capacity_at(step), ep.capacity)
+    ax.add_collection(LineCollection(pos[np.stack([path[:-1], path[1:]], 1)], linewidths=3.2, colors=ACCENT,
+                                     zorder=2, label="descent path of the flow"))
+    valid = hops >= 0
+    start, end = pos[valid], pos[hops[valid]]
+    thin = min(1.0, (100 / ep.n_nodes) ** 0.5)                              # lighter arrows on large graphs
+    ax.quiver(start[:, 0], start[:, 1], (end - start)[:, 0] * 0.55, (end - start)[:, 1] * 0.55,
+              angles="xy", scale_units="xy", scale=1, width=0.0035 * thin, color=INK2, alpha=0.8, zorder=2,
+              headwidth=5, headlength=6, label="steepest-current next hop")
+    norm = Normalize(vmin=0, vmax=phi.max())
+    scatter = ax.scatter(pos[:, 0], pos[:, 1], s=18 + 160 * queue / ds.config.buffer_size, c=phi, cmap=BLUES, norm=norm,
+                         edgecolors=SURFACE, linewidths=0.8, zorder=3)
+    ax.scatter(*pos[source], s=170, marker="s", facecolors="none", edgecolors=ACCENT, linewidths=2, zorder=4, label="source")
+    ax.scatter(*pos[sink], s=260, marker="*", facecolors="none", edgecolors=ACCENT, linewidths=2, zorder=4, label="sink")
+    clean_axes(ax)
+    fig.colorbar(scatter, ax=ax, label="potential of the flow (0 at its sink)", shrink=0.75)
+    ax.legend(loc="upper center", bbox_to_anchor=(0.5, -0.01), ncol=4, fontsize=8)
+    ax.set_title(f"Potential field of tracked flow {flow} ({source} to {sink}), episode {ep.id}, step {step}\n"
+                 f"node size: buffer occupancy under the potential router; link width: base capacity")
+    save(fig, out, "potential_field", dpi)
+
+
+def fig_delays(ds: Dataset, out: Path, dpi: int, **_) -> None:
+    flows = ds.summary("flow_summary")
+    flows = flows[flows.delivered > 0].copy()
+    flows["path_stretch"] = flows.mean_hops / flows.min_hops
+    routers = [r for r in ROUTERS if r in set(flows.router)]
+    fig, axes = plt.subplots(1, 2, figsize=(10, 3.8))
+    for ax, (column, label, log) in zip(axes, [("p99_delay", "flow p99 end-to-end delay (steps)", True),
+                                               ("path_stretch", "flow path stretch (mean hops / shortest hops)", False)]):
+        data = [flows[flows.router == r][column].to_numpy() for r in routers]
+        boxes = ax.boxplot(data, vert=False, widths=0.6, showfliers=False, patch_artist=True,
+                           medianprops={"color": INK, "linewidth": 1.2},
+                           whiskerprops={"color": INK2, "linewidth": 0.8}, capprops={"color": INK2, "linewidth": 0.8})
+        for patch, r in zip(boxes["boxes"], routers):
+            patch.set(facecolor=ROUTER_COLOR[r], edgecolor=SURFACE, alpha=0.9)
+        ax.set_yticks(range(1, len(routers) + 1))
+        ax.set_yticklabels([LABEL[r] for r in routers])
+        ax.invert_yaxis()
+        ax.grid(axis="y", visible=False)
+        if log:
+            ax.set_xscale("log")
+        ax.set_xlabel(label)
+    fig.suptitle(f"Flow-level delay and path stretch per router ({flows.episode_id.nunique()} episodes, "
+                 f"{len(flows) // len(routers):,} delivered flows each; boxes: quartiles, whiskers: 1.5 IQR)", y=1.02)
+    fig.tight_layout()
+    save(fig, out, "delays", dpi)
+
+
+def fig_traffic_profiles(ds: Dataset, out: Path, dpi: int, **_) -> None:
+    episodes = ds.episodes
+    profiles = [p for p in TRAFFIC_PROFILES if p in set(episodes.traffic_profile)]
+    fig, axes = plt.subplots(len(profiles), 1, figsize=(10, 1.9 * len(profiles) + 0.6), sharex=True, squeeze=False)
+    order = {"heavy": 0, "moderate": 1, "light": 2}
+    for ax, profile in zip(axes[:, 0], profiles):
+        candidates = episodes[episodes.traffic_profile == profile]
+        eid = candidates.index[np.argsort(candidates.load_level.map(order).to_numpy(), kind="stable")[0]]
+        ep = ds.episode(eid)
+        f = int(np.argmax(np.asarray(ep.row.flow_mean_rate)[: ep.tracked_flows]))   # largest tracked flow
+        flow = ep.telemetry("flow_telemetry", ds.routers[0], ["episode_id", "router", "step", "flow", "offered", "mmpp_state"])
+        flow = flow[flow.flow == f]
+        shade_bursts(ax, flow.mmpp_state.to_numpy() > 0)
+        ax.plot(flow.step, flow.offered, color=SERIES[0], linewidth=1.0)
+        ax.set_ylabel("packets / step", fontsize=8)
+        ax.set_ylim(bottom=0)
+        ax.set_title(f"{profile}: flow {f} of episode {eid} ({ep.row.load_level} load), mean rate "
+                     f"{ep.row.flow_mean_rate[f]:.2f} packets/step (idle {ep.row.flow_idle_rate[f]:.2f}, "
+                     f"burst {ep.row.flow_burst_rate[f]:.2f})", loc="left")
+    axes[-1, 0].set_xlabel("step (1 step = 1 ms)")
+    fig.suptitle("Traffic profiles: offered packets of one flow (grey bands: burst state)", y=1.0)
+    fig.tight_layout()
+    save(fig, out, "traffic_profiles", dpi)
+
+
+def choose_episode(ds: Dataset) -> int:
+    """A busy episode: heaviest load, burstiest profile and most dynamic level present."""
+    episodes = ds.episodes.reset_index()
+    rank = {"heavy": 0, "moderate": 1, "light": 2}, {"microburst": 0, "sustained": 1, "poisson": 2}, {"severe": 0, "moderate": 1, "static": 2}
+    key = (episodes.load_level.map(rank[0]) * 100 + episodes.traffic_profile.map(rank[1]) * 10
+           + episodes.dynamics_level.map(rank[2]))
+    return int(episodes.episode_id[key.idxmin()])
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--data", type=Path, default=ROOT / "data", help="dataset folder (default: data/)")
+    parser.add_argument("--out", type=Path, default=ROOT / "figures", help="output folder (default: figures/)")
+    parser.add_argument("--figures", default="all", help="comma-separated subset of " + ",".join(FIGURES))
+    parser.add_argument("--episode", type=int, default=None, help="episode for the single-episode figures (default: a busy one)")
+    parser.add_argument("--step", type=int, default=500, help="step for the potential-field figure")
+    parser.add_argument("--flow", type=int, default=0, help="tracked flow for the potential-field figure")
+    parser.add_argument("--routers", default="potential,shortest_path", help="two routers for the timeline and heatmap")
+    parser.add_argument("--dpi", type=int, default=150)
+    parser.add_argument("--seed", type=int, default=0, help="bootstrap seed")
+    args = parser.parse_args()
+
+    style()
+    ds = Dataset(args.data)
+    wanted = FIGURES if args.figures == "all" else tuple(args.figures.split(","))
+    unknown = set(wanted) - set(FIGURES)
+    assert not unknown, f"unknown figures {unknown}; choose from {FIGURES}"
+    routers = tuple(args.routers.split(","))
+    assert all(r in ds.routers for r in routers), f"routers must be among {ds.routers}"
+    episode = choose_episode(ds) if args.episode is None else args.episode
+    print(f"{ds.path}: {len(ds.episodes)} episodes; single-episode figures use episode {episode}")
+    for name in wanted:
+        globals()[f"fig_{name}"](ds, args.out, args.dpi, seed=args.seed, episode=episode,
+                                 step=args.step, flow=args.flow, routers=routers)
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,7 @@
+numpy>=1.26
+scipy>=1.11
+pandas>=2.0
+pyarrow>=15.0
+networkx>=3.1
+huggingface_hub>=0.34
+matplotlib>=3.7

scripts/push_to_huggingface.py

@@ -0,0 +1,45 @@
+"""Publish the generated dataset to the Hugging Face Hub (the one manual step).
+
+    hf auth login                                                   # once, paste a write token
+    python scripts/push_to_huggingface.py --repo <user>/<dataset>   # add --private if you like
+
+The whole project folder becomes the dataset repository: the Parquet shards in data/ (with
+config.json and manifest.json), the README.md dataset card whose `configs:` block makes every
+table browsable in the Dataset Viewer, and the generator source, so the dataset is reproducible
+from the repository alone. The upload is resumable: re-run the same command after any
+interruption and it continues where it stopped (its bookkeeping lives in .cache/, ignored by git).
+"""
+import argparse
+import os
+from pathlib import Path
+
+from huggingface_hub import HfApi
+
+ROOT = Path(__file__).resolve().parents[1]
+IGNORE = ["__pycache__/**", "*.pyc", "*.tmp", ".git/**", ".gitignore", ".cache/**", ".DS_Store",
+          "data_*/**", "*.log"]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--repo", required=True, help="dataset repository id, e.g. alexander/semantic-potential-routing")
+    parser.add_argument("--private", action="store_true", help="create the repository as private")
+    parser.add_argument("--token", default=os.environ.get("HF_TOKEN"), help="write token (default: HF_TOKEN or cached login)")
+    parser.add_argument("--workers", type=int, default=None, help="parallel upload workers (default: library choice)")
+    args = parser.parse_args()
+
+    shards = sorted((ROOT / "data").glob("*/part-*.parquet"))
+    if not shards or not (ROOT / "data" / "manifest.json").exists():
+        raise SystemExit("No finished dataset in data/ - run scripts/run_local_sweep.py first.")
+    print(f"Uploading {len(shards)} Parquet shards "
+          f"({sum(f.stat().st_size for f in shards) / 1e9:.2f} GB) plus README and source to {args.repo} ...")
+
+    api = HfApi(token=args.token)
+    api.create_repo(args.repo, repo_type="dataset", private=args.private, exist_ok=True)
+    api.upload_large_folder(repo_id=args.repo, folder_path=ROOT, repo_type="dataset",
+                            ignore_patterns=IGNORE, num_workers=args.workers)
+    print(f"Done: https://huggingface.co/datasets/{args.repo}")
+
+
+if __name__ == "__main__":
+    main()

scripts/run_local_sweep.py

@@ -0,0 +1,100 @@
+"""Generate the dataset on this machine.
+
+    python scripts/run_local_sweep.py --smoke        # ~1-minute end-to-end check in a temporary folder
+    python scripts/run_local_sweep.py                # full design with the defaults into data/
+    python scripts/run_local_sweep.py --help         # every design level and model knob is a flag
+
+Every CPU core runs independent Monte Carlo episodes; shards are streamed to Parquet as they
+complete, and re-running the same command resumes an interrupted sweep. When the sweep finishes
+the script writes data/manifest.json and prints the router benchmark, the design coverage and the
+size of every table.
+"""
+import os
+
+for _var in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"):
+    os.environ.setdefault(_var, "1")  # one BLAS thread per worker process; parallelism comes from the pool
+
+import argparse
+import shutil
+import sys
+import tempfile
+from dataclasses import fields, replace
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from src.config import DATASET_VERSION, SimConfig  # noqa: E402
+from src.simulation_loop import run_sweep  # noqa: E402
+from src.telemetry_logger import read_table, write_manifest  # noqa: E402
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--out", type=Path, default=ROOT / "data", help="output folder (default: data/)")
+    parser.add_argument("--workers", type=int, default=os.cpu_count(), help="worker processes (default: all cores)")
+    parser.add_argument("--smoke", action="store_true", help="tiny sweep over every family, profile and router "
+                                                             "in a temporary folder, deleted afterwards")
+    group = parser.add_argument_group("design and model configuration")
+    for f in fields(SimConfig):
+        if isinstance(f.default, tuple):
+            item = type(f.default[0])
+            kind = lambda s, item=item: tuple(item(x) for x in s.split(","))  # noqa: E731
+            shown = ",".join(str(x) for x in f.default)
+        else:
+            kind, shown = type(f.default), f.default
+        group.add_argument(f"--{f.name}", type=kind, default=None, metavar="",
+                           help=f"{f.metadata['help']} (default: {shown})")
+    return parser.parse_args()
+
+
+def summarize(data_dir: Path, cfg: SimConfig) -> None:
+    manifest = write_manifest(data_dir, cfg, DATASET_VERSION)
+    summary = read_table(data_dir, "router_summary").to_pandas()
+    bench = summary.groupby("router").agg(
+        loss_ratio=("loss_ratio", "mean"), mean_delay=("mean_delay", "mean"), p99_delay=("p99_delay", "mean"),
+        link_utilisation=("link_utilisation", "mean"), route_changes=("route_changes", "mean"))
+    print("\nRouter benchmark (means over episodes):")
+    print(bench.round(3).to_string())
+    print("\nDesign coverage (episodes per level):")
+    for factor, counts in manifest["coverage"].items():
+        print(f"  {factor:16s} " + "  ".join(f"{k}={v}" for k, v in counts.items()))
+    design = manifest["design"]
+    print(f"  cells {design['cells']}, episodes {design['episodes_present']}/{design['episodes_planned']}, "
+          f"per cell {design['episodes_per_cell_min']}-{design['episodes_per_cell_max']}")
+    print("\nTables:")
+    total = 0
+    for name, stats in manifest["tables"].items():
+        total += stats["bytes"]
+        print(f"  {name:18s} {stats['files']:5d} files {stats['rows']:14,d} rows {stats['bytes'] / 1e9:8.2f} GB")
+    print(f"  {'total':18s} {'':5s}       {'':14s}      {total / 1e9:8.2f} GB")
+
+
+def main() -> None:
+    args = parse_args()
+    overrides = {f.name: getattr(args, f.name) for f in fields(SimConfig) if getattr(args, f.name) is not None}
+    cfg = SimConfig(**overrides)
+    data_dir = args.out
+    if args.smoke:
+        cfg = replace(cfg, replicates=1, sizes=(32,), load_levels=("heavy",), dynamics_levels=("severe",),
+                      steps=200, shard_episodes=5)
+        data_dir = Path(tempfile.mkdtemp(prefix="sprt-smoke-"))
+        print(f"Smoke test in {data_dir}")
+    data_dir.mkdir(parents=True, exist_ok=True)
+    config_path = data_dir / "config.json"
+    if config_path.exists() and SimConfig.load(config_path) != cfg:
+        sys.exit(f"{config_path} was written by a different configuration; use another --out folder "
+                 f"or delete it to start over.")
+    cfg.save(config_path)
+    try:
+        run_sweep(cfg, data_dir, max(1, min(args.workers, cfg.episodes)))
+        summarize(data_dir, cfg)
+        if args.smoke:
+            print("\nSmoke test passed.")
+    finally:
+        if args.smoke:
+            shutil.rmtree(data_dir, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/validate_dataset.py

@@ -0,0 +1,375 @@
+"""Validate a generated dataset: structure, design coverage, physical invariants and reproducibility.
+
+    python scripts/validate_dataset.py                 # validates data/
+    python scripts/validate_dataset.py --out data_large --resimulate 5
+
+Checks, in order: every shard has every table; the design is balanced and the splits present;
+packet conservation and metric consistency across the summary and telemetry tables; buffers,
+link loads and potentials respect their physical bounds; a sample of episodes re-simulated from
+``config.json`` reproduces the stored tables bit for bit; and a stored potential-field snapshot
+is recovered from the graph state and queue depths with the sparse SuperLU reference solver.
+Exits with status 1 if any check fails.
+
+The step-level tables are far larger than memory at the full design (``flow_telemetry`` alone is
+episodes x routers x steps x tracked_flows = 2.6e8 rows), so every check over them streams the
+shards one record batch at a time and folds partial aggregates together; peak memory is a few
+hundred MB regardless of dataset size.
+"""
+import os
+
+for _var in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"):
+    os.environ.setdefault(_var, "1")
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Iterator, Sequence
+
+import numpy as np
+import pyarrow as pa
+import pyarrow.dataset as pads
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from src.config import SimConfig  # noqa: E402
+from src.graph_generator import effective_capacity, TopologyEvent, Topology  # noqa: E402
+from src.physics_engine import grounded_solve, live_graph  # noqa: E402
+from src.simulation_loop import simulate_episode  # noqa: E402
+from src.telemetry_logger import read_table, shard_files, table_names  # noqa: E402
+
+BATCH_ROWS = 1 << 18   # rows per streamed record batch (~10 MB for the scalar telemetry columns)
+READAHEAD = 2          # batches/fragments the scanner may buffer ahead; keeps peak memory flat
+FOLD_EVERY = 8         # partial aggregates combined before they accumulate
+
+failures = []
+
+
+def check(condition: bool, message: str) -> None:
+    status = "ok " if condition else "FAIL"
+    print(f"  [{status}] {message}")
+    if not condition:
+        failures.append(message)
+
+
+# --------------------------------------------------------------------------------------
+# Streaming helpers.  Nothing below ever materialises a whole step-level table: the shards are
+# read one record batch at a time and folded into a dense per-group accumulator whose size is
+# fixed by the design (episodes x routers x tracked flows), not by the number of rows.
+# --------------------------------------------------------------------------------------
+
+def scan(data_dir: Path, table: str, columns: Sequence[str], filter=None,
+         batch_rows: int = BATCH_ROWS) -> Iterator[pa.RecordBatch]:
+    """Record batches of a table's shards, reading only `columns`."""
+    files = [str(p) for p in shard_files(data_dir, table)]
+    dataset = pads.dataset(files, format="parquet")
+    yield from dataset.to_batches(columns=list(columns), filter=filter, batch_size=batch_rows,
+                                  batch_readahead=READAHEAD, fragment_readahead=READAHEAD)
+
+
+class Groups:
+    """Dense (episode, router[, flow]) -> slot mapping shared by a telemetry and a summary table."""
+
+    def __init__(self, episode_ids: Sequence[int], routers: Sequence[str], width: int = 1):
+        ids = np.asarray(sorted(int(e) for e in episode_ids), np.int64)
+        self.episode_ids = ids
+        self.lookup = np.full(int(ids.max()) + 1, -1, np.int64)
+        self.lookup[ids] = np.arange(len(ids))
+        self.routers = list(routers)
+        self.router_slot = {r: i for i, r in enumerate(self.routers)}
+        self.width = int(width)
+        self.size = len(ids) * len(self.routers) * self.width
+
+    def slots(self, batch: pa.RecordBatch) -> np.ndarray:
+        episode = self.lookup[batch.column("episode_id").to_numpy(zero_copy_only=False).astype(np.int64)]
+        encoded = batch.column("router").dictionary_encode()
+        codes = np.array([self.router_slot[v] for v in encoded.dictionary.to_pylist()], np.int64)
+        router = codes[encoded.indices.to_numpy(zero_copy_only=False).astype(np.int64)]
+        slot = (episode * len(self.routers) + router) * self.width
+        if self.width > 1:
+            slot = slot + batch.column("flow").to_numpy(zero_copy_only=False).astype(np.int64)
+        return slot
+
+    def label(self, slot: int) -> str:
+        episode, rest = divmod(int(slot), len(self.routers) * self.width)
+        router, flow = divmod(rest, self.width)
+        name = f"episode {self.episode_ids[episode]}, router {self.routers[router]}"
+        return name + (f", flow {flow}" if self.width > 1 else "")
+
+
+class Sums:
+    """Per-group sums of integer counters, accumulated batch by batch."""
+
+    def __init__(self, groups: Groups, values: Sequence[str]):
+        self.groups = groups
+        self.values = list(values)
+        self.rows = np.zeros(groups.size, np.int64)
+        self.totals = {v: np.zeros(groups.size, np.int64) for v in self.values}
+
+    def add(self, batch: pa.RecordBatch) -> None:
+        slot = self.groups.slots(batch)
+        self.rows += np.bincount(slot, minlength=self.groups.size)
+        for name in self.values:
+            column = batch.column(name).to_numpy(zero_copy_only=False).astype(np.float64)
+            self.totals[name] += np.rint(np.bincount(slot, weights=column,
+                                                     minlength=self.groups.size)).astype(np.int64)
+
+    @property
+    def present(self) -> np.ndarray:
+        return self.rows > 0
+
+
+def accumulate(data_dir: Path, table: str, groups: Groups, values: Sequence[str],
+               batch_rows: int = BATCH_ROWS, on_batch=None) -> Sums:
+    """Stream `table` and sum `values` per group."""
+    sums = Sums(groups, values)
+    columns = ["episode_id", "router"] + (["flow"] if groups.width > 1 else [])
+    extra = [v for v in values if v not in columns]
+    for batch in scan(data_dir, table, columns + extra, batch_rows=batch_rows):
+        if on_batch is not None:
+            on_batch(batch)
+        sums.add(batch)
+    return sums
+
+
+def compare_sums(streamed: Sums, reference: Sums, columns: Sequence[str], label: str) -> None:
+    """Check that per-group sums streamed from a telemetry table equal those of a summary table."""
+    groups = streamed.groups
+    same_groups = bool((streamed.present == reference.present).all())
+    if not same_groups:
+        missing = np.flatnonzero(streamed.present != reference.present)
+        check(False, f"{label}: {len(missing)} group(s) on one side only, e.g. {groups.label(missing[0])}")
+        return
+    check(True, f"{label}: the same groups appear in both tables")
+    where = streamed.present
+    bad = [c for c in columns if not bool((streamed.totals[c][where] == reference.totals[c][where]).all())]
+    if bad:
+        c = bad[0]
+        first = np.flatnonzero(where & (streamed.totals[c] != reference.totals[c]))[0]
+        check(False, f"{label} (differs in {', '.join(bad)}; first at {groups.label(first)}: "
+                     f"{streamed.totals[c][first]} vs {reference.totals[c][first]})")
+    else:
+        check(True, label)
+
+
+# --------------------------------------------------------------------------------------
+# Checks
+# --------------------------------------------------------------------------------------
+
+def structure(data_dir: Path, cfg: SimConfig) -> int:
+    print("Structure")
+    tables = table_names(cfg.routers)
+    counts = {t: len(shard_files(data_dir, t)) for t in tables}
+    n_shards = max(counts.values()) if counts else 0
+    check(n_shards > 0, f"{n_shards} shards present")
+    check(all(c == n_shards for c in counts.values()), "every table has every shard")
+    check((data_dir / "manifest.json").exists(), "manifest.json present")
+    return n_shards
+
+
+def coverage(data_dir: Path, cfg: SimConfig) -> None:
+    print("Design coverage")
+    ep = read_table(data_dir, "episodes", columns=["episode_id", "cell_id", "replicate", "split"]).to_pandas()
+    per_cell = ep.cell_id.value_counts()
+    check(len(per_cell) == len(cfg.cells), f"all {len(cfg.cells)} design cells present")
+    check(per_cell.max() - per_cell.min() <= 1, f"balanced: {per_cell.min()}-{per_cell.max()} episodes per cell")
+    check(ep.episode_id.is_unique, "episode ids unique")
+    check({"train", "validation", "test"} <= set(ep.split) or cfg.replicates < 5,
+          f"splits present: {sorted(set(ep.split))}")
+
+
+FLOW_SUMMARY_COLUMNS = ["offered", "delivered", "dropped", "in_flight", "loss_ratio", "mean_delay",
+                        "min_latency", "min_hops", "mean_hops", "p50_delay", "p95_delay", "p99_delay",
+                        "max_delay", "mean_queueing_delay", "mean_path_latency"]
+
+
+def flow_summary_elementwise(data_dir: Path, batch_rows: int) -> None:
+    """Per-row invariants of flow_summary, accumulated over streamed batches."""
+    results = dict(conservation=True, loss=True, delay=True, hops=True, quantiles=True, decomposition=True)
+    for batch in scan(data_dir, "flow_summary", FLOW_SUMMARY_COLUMNS, batch_rows=batch_rows):
+        c = {name: batch.column(name).to_numpy(zero_copy_only=False) for name in FLOW_SUMMARY_COLUMNS}
+        ok = c["delivered"] > 0
+        results["conservation"] &= bool((c["offered"] == c["delivered"] + c["dropped"] + c["in_flight"]).all())
+        results["loss"] &= bool(((c["loss_ratio"] >= 0) & (c["loss_ratio"] <= 1)).all())
+        results["delay"] &= bool((c["mean_delay"][ok] >= c["min_latency"][ok] - 1e-3).all())
+        results["hops"] &= bool((c["mean_hops"][ok] >= c["min_hops"][ok] - 1e-3).all())
+        results["quantiles"] &= bool(((c["p50_delay"][ok] <= c["p95_delay"][ok] + 1e-3)
+                                      & (c["p95_delay"][ok] <= c["p99_delay"][ok] + 1e-3)
+                                      & (c["p99_delay"][ok] <= c["max_delay"][ok] + 1e-3)).all())
+        results["decomposition"] &= bool(np.allclose(c["mean_delay"][ok],
+                                                     c["mean_queueing_delay"][ok] + c["mean_path_latency"][ok],
+                                                     atol=1e-2))
+    check(results["conservation"], "flow conservation: offered = delivered + dropped + in-flight")
+    check(results["loss"], "loss ratio within [0, 1]")
+    check(results["delay"], "mean delay >= minimum path latency")
+    check(results["hops"], "mean hops >= minimum hop count")
+    check(results["quantiles"], "delay quantiles ordered")
+    check(results["decomposition"], "delay = queueing + propagation")
+
+
+def invariants(data_dir: Path, cfg: SimConfig, batch_rows: int = BATCH_ROWS) -> None:
+    print("Invariants")
+    flow_summary_elementwise(data_dir, batch_rows)
+
+    episode_ids = read_table(data_dir, "episodes", columns=["episode_id"]).column("episode_id").to_pylist()
+    counters = ["offered", "delivered", "dropped", "in_flight"]
+    per_router = Groups(episode_ids, cfg.routers)
+
+    router_summary = read_table(data_dir, "router_summary")
+    reference = Sums(per_router, counters)
+    for batch in router_summary.to_batches():
+        reference.add(batch)
+    check(bool((reference.rows <= 1).all()), "router_summary has one row per (episode, router)")
+    compare_sums(accumulate(data_dir, "flow_summary", per_router, counters, batch_rows),
+                 reference, counters, "router summary equals the sum of its flows")
+    util = router_summary.column("link_utilisation").to_numpy(zero_copy_only=False)
+    sat = router_summary.column("link_saturation").to_numpy(zero_copy_only=False)
+    check(bool(((util >= 0) & (util <= 1) & (sat >= 0) & (sat <= 1)).all()), "utilisation within [0, 1]")
+
+    admission = {"ok": True}
+
+    def admitted_le_offered(batch: pa.RecordBatch) -> None:
+        admission["ok"] &= bool((batch.column("admitted").to_numpy(zero_copy_only=False)
+                                 <= batch.column("offered").to_numpy(zero_copy_only=False)).all())
+
+    steps = ["offered", "delivered", "dropped"]
+    compare_sums(accumulate(data_dir, "network_telemetry", per_router, steps + ["admitted"], batch_rows,
+                            on_batch=admitted_le_offered),
+                 reference, steps, "network telemetry sums to the router summary")
+
+    per_flow = Groups(episode_ids, cfg.routers, width=int(cfg.tracked_flows))
+    tracked = accumulate(data_dir, "flow_telemetry", per_flow, steps + ["admitted"], batch_rows,
+                         on_batch=admitted_le_offered)
+    flow_reference = Sums(per_flow, steps)
+    for batch in scan(data_dir, "flow_summary", ["episode_id", "router", "flow"] + steps,
+                      filter=pads.field("flow") < int(cfg.tracked_flows), batch_rows=batch_rows):
+        flow_reference.add(batch)
+    compare_sums(tracked, flow_reference, steps, "tracked-flow telemetry sums to the flow summary")
+    check(admission["ok"], "admitted <= offered")
+
+
+def physical_bounds(data_dir: Path, cfg: SimConfig, episode_ids) -> None:
+    print("Physical bounds (sampled episodes)")
+    episodes = read_table(data_dir, "episodes").to_pandas().set_index("episode_id")
+    events = read_table(data_dir, "events").to_pandas()
+    for eid in episode_ids:
+        ep = episodes.loc[eid]
+        net = read_table(data_dir, "network_telemetry", filters=[("episode_id", "=", int(eid))]).to_pandas()
+        queue = np.stack(net.queue_depth)
+        check(queue.min() >= 0 and queue.max() <= cfg.buffer_size, f"episode {eid}: queue depths within the buffer")
+        check((np.stack(net.node_dropped).sum(1) == net.dropped).all(), f"episode {eid}: node drops sum to step drops")
+        link = read_table(data_dir, "link_telemetry", filters=[("episode_id", "=", int(eid))]).to_pandas()
+        topo = Topology(int(ep.n_nodes), np.stack([ep.edge_u, ep.edge_v], 1).astype(np.int16),
+                        ep.capacity.astype(np.int16), ep.latency.astype(np.int16),
+                        np.zeros(0, np.int16), np.zeros(0, np.int8), np.zeros((0, 2), np.float32))
+        evs = [TopologyEvent(e.kind, int(e.start), int(e.end),
+                             edge=int(np.flatnonzero((ep.edge_u == e.edge_u) & (ep.edge_v == e.edge_v))[0]) if e.kind == "link_failure" else -1,
+                             node=int(e.node), factor=float(e.factor))
+               for e in events[events.episode_id == eid].itertuples()]
+        steps = sorted({0} | {e.start for e in evs} | {e.end for e in evs if e.end < ep.steps})
+        cap_at = {t: effective_capacity(topo, evs, t) for t in steps}
+        bounds = np.array([cap_at[steps[np.searchsorted(steps, t, side="right") - 1]] for t in link.step])
+        loads = np.maximum(np.stack(link.load_uv), np.stack(link.load_vu))
+        check((loads <= bounds).all(), f"episode {eid}: link loads never exceed the capacity in force")
+        if "potential_field" in table_names(cfg.routers):
+            pf = read_table(data_dir, "potential_field", filters=[("episode_id", "=", int(eid))]).to_pandas()
+            phi = np.stack(pf.potential).reshape(len(pf), int(ep.tracked_flows), int(ep.n_nodes))
+            sinks = ep.flow_sink[: int(ep.tracked_flows)]
+            check(phi.min() >= 0 and np.all(phi[:, np.arange(len(sinks)), sinks] == 0),
+                  f"episode {eid}: potentials non-negative and zero at the sinks")
+
+
+def tables_equal(a: pa.Table, b: pa.Table) -> bool:
+    """Exact equality of two tables, treating NaN as equal to NaN."""
+    if a.num_rows != b.num_rows or not a.schema.equals(b.schema, check_metadata=False):
+        return False
+    for name in a.column_names:
+        x, y = a.column(name).combine_chunks(), b.column(name).combine_chunks()
+        if pa.types.is_list(x.type):
+            if not x.offsets.equals(y.offsets):
+                return False
+            x, y = x.flatten(), y.flatten()
+        if pa.types.is_floating(x.type):
+            if not np.array_equal(x.to_numpy(zero_copy_only=False), y.to_numpy(zero_copy_only=False), equal_nan=True):
+                return False
+        elif not x.equals(y):
+            return False
+    return True
+
+
+def reproducibility(data_dir: Path, cfg: SimConfig, episode_ids) -> None:
+    print("Reproducibility (re-simulating from config.json)")
+    for eid in episode_ids:
+        fresh = simulate_episode(cfg, int(eid))
+        same = all(tables_equal(read_table(data_dir, name, filters=[("episode_id", "=", int(eid))]), table)
+                   for name, table in fresh.items())
+        check(same, f"episode {eid}: every table reproduced bit for bit")
+
+
+def field_reconstruction(data_dir: Path, cfg: SimConfig, eid: int) -> None:
+    print("Potential-field reconstruction (sparse reference solver)")
+    ep = read_table(data_dir, "episodes", filters=[("episode_id", "=", int(eid))]).to_pandas().iloc[0]
+    events = read_table(data_dir, "events", filters=[("episode_id", "=", int(eid))]).to_pandas()
+    pf = read_table(data_dir, "potential_field", filters=[("episode_id", "=", int(eid))]).to_pandas()
+    row = pf.iloc[len(pf) // 2]
+    step = int(row.step)
+    net = read_table(data_dir, "network_telemetry",
+                     filters=[("episode_id", "=", int(eid)), ("router", "=", "potential"), ("step", "=", step)]).to_pandas()
+    queue = np.asarray(net.queue_depth.iloc[0], np.float64)
+    n = int(ep.n_nodes)
+    cap = ep.capacity.astype(np.float64)
+    factor, failed = np.ones(n), np.zeros(len(cap), bool)
+    for e in events[(events.start <= step) & (step < events.end)].itertuples():
+        if e.kind == "node_degradation":
+            factor[e.node] *= e.factor
+        else:
+            failed |= (ep.edge_u == e.edge_u) & (ep.edge_v == e.edge_v)
+    cap = np.maximum(1, np.floor(cap * factor[ep.edge_u] * factor[ep.edge_v]))
+    cap[failed] = 0
+    g = live_graph(n, np.stack([ep.edge_u, ep.edge_v], 1), cap.astype(np.int16), ep.latency.astype(np.int16))
+    stored = np.asarray(row.potential, np.float64).reshape(int(ep.tracked_flows), n)
+    injection = cfg.background_injection / (n - 1) + cfg.congestion_gain * queue / cfg.buffer_size
+    worst = 0.0
+    for f in range(int(ep.tracked_flows)):
+        b = injection.copy()
+        b[ep.flow_source[f]] += cfg.source_injection
+        phi = grounded_solve(g, int(ep.flow_sink[f]), b)
+        worst = max(worst, np.abs(phi - stored[f]).max() / max(np.abs(phi).max(), 1e-12))
+    check(worst < 1e-5, f"episode {eid}, step {step}: stored field matches the sparse solve (max rel err {worst:.1e})")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--out", type=Path, default=ROOT / "data", help="dataset folder (default: data/)")
+    parser.add_argument("--resimulate", type=int, default=3, help="episodes to re-simulate for the reproducibility check")
+    parser.add_argument("--seed", type=int, default=0, help="seed for choosing the sampled episodes")
+    parser.add_argument("--batch-rows", type=int, default=BATCH_ROWS,
+                        help=f"rows per streamed record batch in the invariant checks (default: {BATCH_ROWS})")
+    args = parser.parse_args()
+    cfg = SimConfig.load(args.out / "config.json")
+    n_shards = structure(args.out, cfg)
+    if n_shards == 0:
+        sys.exit("no shards found")
+    coverage(args.out, cfg)
+    invariants(args.out, cfg, max(1024, args.batch_rows))
+    ids = read_table(args.out, "episodes", columns=["episode_id", "size"]).to_pandas().sort_values("size")
+    rng = np.random.default_rng(args.seed)
+    sample = [int(ids.episode_id.iloc[i]) for i in
+              np.unique(np.linspace(0, len(ids) - 1, max(1, args.resimulate)).astype(int))]
+    if len(ids) > args.resimulate:
+        sample = sorted(set(sample) | {int(x) for x in rng.choice(ids.episode_id, 1, replace=False)})
+    physical_bounds(args.out, cfg, sample)
+    reproducibility(args.out, cfg, sample[:args.resimulate])
+    if "potential_field" in table_names(cfg.routers):
+        field_reconstruction(args.out, cfg, sample[0])
+    manifest = json.loads((args.out / "manifest.json").read_text(encoding="utf-8"))
+    print(f"\nDataset v{manifest['dataset_version']}: {manifest['design']['episodes_present']} episodes, "
+          f"{sum(t['bytes'] for t in manifest['tables'].values()) / 1e9:.2f} GB")
+    if failures:
+        sys.exit(f"{len(failures)} check(s) failed: " + "; ".join(failures))
+    print("All checks passed.")
+
+
+if __name__ == "__main__":
+    main()

src/__init__.py

@@ -0,0 +1 @@
+"""Semantic Potential Routing Telemetry: training-free potential-field routing under stochastic congestion."""

src/config.py

@@ -0,0 +1,102 @@
+"""Generator configuration.
+
+One frozen dataclass holds every knob: which levels of the experimental design to generate, how
+many replicates per cell, the physical model constants and the potential-field parameters.
+``scripts/run_local_sweep.py`` turns each field into a command-line flag, and the resolved
+configuration is written next to the data as ``data/config.json`` so that any episode can be
+re-created bit for bit from ``(config, episode_id)``.
+"""
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field, fields
+from pathlib import Path
+from typing import List
+
+from . import design
+
+DATASET_VERSION = "2.0"
+ROUTERS = ("potential", "potential_split", "potential_static",
+           "shortest_path", "ecmp", "adaptive_shortest_path")
+
+
+def _f(default, help_text):
+    return field(default=default, metadata={"help": help_text})
+
+
+@dataclass(frozen=True)
+class SimConfig:
+    # Experimental design (see src/design.py for the level definitions)
+    replicates: int = _f(10, "episodes per design cell; episodes = replicates x cells")
+    topologies: tuple = _f(design.TOPOLOGIES, "topology families to include")
+    sizes: tuple = _f(design.SIZES, "nominal network sizes to include")
+    traffic_profiles: tuple = _f(tuple(design.TRAFFIC_PROFILES), "traffic profiles to include")
+    load_levels: tuple = _f(tuple(design.LOAD_LEVELS), "load levels to include")
+    dynamics_levels: tuple = _f(tuple(design.DYNAMICS_LEVELS), "topology-dynamics levels to include")
+    routers: tuple = _f(ROUTERS, "routers replayed on identical traffic and events")
+
+    # Sweep
+    seed: int = _f(2026, "base seed; episode e draws from numpy default_rng([seed, e])")
+    shard_episodes: int = _f(40, "episodes per Parquet shard (one shard = one resumable unit)")
+    field_budget_bytes: int = _f(1_000_000, "potential field of the tracked flows is logged every k steps to stay within this budget")
+
+    # Physical model
+    steps: int = _f(1000, "simulated steps per episode (1 step = 1 ms)")
+    buffer_size: int = _f(256, "per-node drop-tail buffer in packets (< 32768)")
+    mean_degree: int = _f(6, "target mean degree of the random-graph families")
+    capacity_range: tuple = _f((8, 80), "link capacity in packets/step for random graphs (1 pkt/step ~ 12 Mbps)")
+    latency_range: tuple = _f((1, 10), "link propagation delay in steps for random graphs")
+    fat_tree_capacity: int = _f(40, "fat-tree fabric link capacity, packets/step (host links carry twice this)")
+    flows_per_endpoint: int = _f(2, "flows per endpoint node; sources and sinks are distinct ordered pairs")
+    tracked_flows: int = _f(8, "flows per episode with step-level telemetry and stored potential field")
+
+    # Potential field  L_g phi = b  with  b = source + background/(N-1) + gain * queue/buffer
+    source_injection: float = _f(1.0, "unit injection at a flow's source")
+    background_injection: float = _f(0.5, "total background injection spread over all non-sink nodes")
+    congestion_gain: float = _f(2.0, "repulsive injection of a full buffer (alpha)")
+
+    def __post_init__(self):
+        for f in fields(self):  # JSON round-trips turn tuples into lists
+            if isinstance(f.default, tuple):
+                object.__setattr__(self, f.name, tuple(getattr(self, f.name)))
+        for name, allowed in (("topologies", design.TOPOLOGIES), ("sizes", design.SIZES),
+                              ("traffic_profiles", design.TRAFFIC_PROFILES), ("load_levels", design.LOAD_LEVELS),
+                              ("dynamics_levels", design.DYNAMICS_LEVELS), ("routers", ROUTERS)):
+            chosen = getattr(self, name)
+            if not chosen or set(chosen) - set(allowed):
+                raise ValueError(f"{name} must be a non-empty subset of {tuple(allowed)}, got {chosen}")
+        if self.replicates < 1:
+            raise ValueError("replicates must be at least 1")
+        if not 0 < self.buffer_size < 32768:
+            raise ValueError("buffer_size must fit in an int16 telemetry column (< 32768)")
+        if self.flows_per_endpoint < 1 or self.tracked_flows < 1:
+            raise ValueError("flows_per_endpoint and tracked_flows must be positive")
+        if self.mean_degree < 2:
+            raise ValueError("mean_degree must be at least 2")
+        for name in ("capacity_range", "latency_range"):
+            lo, hi = getattr(self, name)
+            if not 0 < lo <= hi:
+                raise ValueError(f"{name} must satisfy 0 < low <= high, got {(lo, hi)}")
+        if self.background_injection <= 0:
+            raise ValueError("background_injection must be positive: it guarantees loop-free descent")
+
+    @property
+    def cells(self) -> List[design.Cell]:
+        return design.cells(self.topologies, self.sizes, self.traffic_profiles, self.load_levels, self.dynamics_levels)
+
+    @property
+    def episodes(self) -> int:
+        return self.replicates * len(self.cells)
+
+    def to_json(self) -> str:
+        return json.dumps(asdict(self), indent=2)
+
+    def save(self, path: Path) -> None:
+        path.write_text(self.to_json(), encoding="utf-8")
+
+    @classmethod
+    def load(cls, path: Path) -> "SimConfig":
+        return cls(**json.loads(path.read_text(encoding="utf-8")))
+
+    def __eq__(self, other) -> bool:  # tuples vs. JSON lists compare equal
+        return isinstance(other, SimConfig) and self.to_json() == other.to_json()

src/dataset.py

@@ -0,0 +1,195 @@
+"""Read access to a generated dataset.
+
+``Dataset`` opens a data folder (or any folder of shards) and returns tables as pandas
+DataFrames; ``Episode`` bundles everything about one episode — the static graph, its event
+timeline, the flows, the telemetry of any router — and rebuilds the physical state at any step:
+the live graph with the capacities in force and the potential field of any flow, recomputed
+exactly with the same engine that generated the data. The example scripts are written against
+this API.
+"""
+from __future__ import annotations
+
+import json
+from functools import cached_property
+from pathlib import Path
+from typing import Dict, List, Optional, Sequence
+
+import numpy as np
+import pandas as pd
+
+from .config import SimConfig
+from .graph_generator import Topology, TopologyEvent, effective_capacity
+from .physics_engine import LiveGraph, PotentialField, currents, live_graph, steepest_next_hops
+from .telemetry_logger import read_table, shard_files, table_names
+
+FACTORS = ("topology", "size", "traffic_profile", "load_level", "dynamics_level")
+
+
+class Dataset:
+    def __init__(self, path):
+        self.path = Path(path)
+        self.config = SimConfig.load(self.path / "config.json")
+        manifest = self.path / "manifest.json"
+        self.manifest: Optional[Dict] = json.loads(manifest.read_text(encoding="utf-8")) if manifest.exists() else None
+
+    @property
+    def tables(self) -> List[str]:
+        return [t for t in table_names(self.config.routers) if shard_files(self.path, t)]
+
+    @property
+    def routers(self) -> Sequence[str]:
+        return self.config.routers
+
+    def table(self, name: str, columns=None, filters=None) -> pd.DataFrame:
+        return read_table(self.path, name, columns=columns, filters=filters).to_pandas()
+
+    @cached_property
+    def episodes(self) -> pd.DataFrame:
+        """The ``episodes`` table indexed by ``episode_id`` (list columns included)."""
+        return self.table("episodes").set_index("episode_id").sort_index()
+
+    def summary(self, name: str = "router_summary") -> pd.DataFrame:
+        """A summary table joined with the design factors and the split of its episode."""
+        keys = list(FACTORS) + ["split", "replicate", "n_nodes", "n_flows", "total_capacity"]
+        return self.table(name).join(self.episodes[keys], on="episode_id")
+
+    def episode(self, episode_id: int) -> "Episode":
+        return Episode(self, int(episode_id))
+
+
+class Episode:
+    def __init__(self, dataset: Dataset, episode_id: int):
+        self.dataset = dataset
+        self.id = episode_id
+        self.row = dataset.episodes.loc[episode_id]
+        self.config = dataset.config
+        self.events = dataset.table("events", filters=[("episode_id", "=", episode_id)]).sort_values("start")
+        self.n_nodes, self.n_edges = int(self.row.n_nodes), int(self.row.n_edges)
+        self.n_flows, self.tracked_flows = int(self.row.n_flows), int(self.row.tracked_flows)
+        self.steps, self.field_stride = int(self.row.steps), int(self.row.field_stride)
+        self.edges = np.stack([self.row.edge_u, self.row.edge_v], 1).astype(np.int16)
+        self.capacity = np.asarray(self.row.capacity, np.int16)
+        self.latency = np.asarray(self.row.latency, np.int16)
+        self.node_role = np.asarray(self.row.node_role, np.int8)
+        self.node_xy = (np.stack([self.row.node_x, self.row.node_y], 1).astype(np.float32)
+                        if len(self.row.node_x) else np.zeros((0, 2), np.float32))
+        self.source = np.asarray(self.row.flow_source, np.int16)
+        self.sink = np.asarray(self.row.flow_sink, np.int16)
+
+    def __repr__(self) -> str:
+        cell = "/".join(str(self.row[f]) for f in FACTORS)
+        return (f"Episode {self.id} [{cell}] {self.n_nodes} nodes, {self.n_edges} links, "
+                f"{self.n_flows} flows, {self.steps} steps, split={self.row.split}")
+
+    @property
+    def cell(self) -> Dict[str, object]:
+        return {f: self.row[f] for f in FACTORS}
+
+    @cached_property
+    def topology(self) -> Topology:
+        return Topology(self.n_nodes, self.edges, self.capacity, self.latency,
+                        np.flatnonzero(self.node_role == self.node_role.max()).astype(np.int16)
+                        if self.node_role.max() > 0 else np.arange(self.n_nodes, dtype=np.int16),
+                        self.node_role, self.node_xy)
+
+    @cached_property
+    def timeline(self) -> List[TopologyEvent]:
+        """The event table as generator objects (link failures resolved to edge indices)."""
+        edge_index = {(int(u), int(v)): i for i, (u, v) in enumerate(self.edges)}
+        return [TopologyEvent(e.kind, int(e.start), int(e.end),
+                              edge=edge_index[(int(e.edge_u), int(e.edge_v))] if e.kind == "link_failure" else -1,
+                              node=int(e.node), factor=float(e.factor))
+                for e in self.events.itertuples()]
+
+    @cached_property
+    def change_steps(self) -> List[int]:
+        steps = {0} | {e.start for e in self.timeline} | {e.end for e in self.timeline if e.end < self.steps}
+        return sorted(steps)
+
+    def capacity_at(self, step: int) -> np.ndarray:
+        """Effective capacity of every link at `step` (0 while failed)."""
+        return effective_capacity(self.topology, self.timeline, step)
+
+    def live_graph(self, step: int = 0) -> LiveGraph:
+        return live_graph(self.n_nodes, self.edges, self.capacity_at(step), self.latency)
+
+    def capacity_matrix(self, step: int) -> np.ndarray:
+        """Dense symmetric N × N matrix of the capacities in force at `step` (the graph state)."""
+        cap = self.capacity_at(step)
+        matrix = np.zeros((self.n_nodes, self.n_nodes), np.int32)
+        matrix[self.edges[:, 0], self.edges[:, 1]] = cap
+        matrix[self.edges[:, 1], self.edges[:, 0]] = cap
+        return matrix
+
+    def telemetry(self, table: str, router: Optional[str] = None, columns=None) -> pd.DataFrame:
+        """Rows of a telemetry table for this episode (and router), sorted by step."""
+        filters = [("episode_id", "=", self.id)] + ([("router", "=", router)] if router else [])
+        frame = self.dataset.table(table, columns=columns, filters=filters)
+        keys = [c for c in ("router", "step", "flow") if c in frame.columns]
+        return frame.sort_values(keys).reset_index(drop=True)
+
+    def queue_depth(self, router: str) -> np.ndarray:
+        """(steps, n_nodes) buffer occupancy after admission, before forwarding."""
+        return np.stack(self.telemetry("network_telemetry", router, ["episode_id", "router", "step", "queue_depth"]).queue_depth)
+
+    def node_dropped(self, router: str) -> np.ndarray:
+        return np.stack(self.telemetry("network_telemetry", router, ["episode_id", "router", "step", "node_dropped"]).node_dropped)
+
+    def link_load(self, router: str) -> np.ndarray:
+        """(steps, n_edges, 2) packets forwarded per link and direction (u→v, v→u)."""
+        frame = self.telemetry("link_telemetry", router)
+        return np.stack([np.stack(frame.load_uv), np.stack(frame.load_vu)], axis=2)
+
+    def link_utilisation(self, router: str) -> np.ndarray:
+        """(steps, n_edges, 2) load divided by the capacity in force; NaN while a link is failed."""
+        load = self.link_load(router).astype(np.float64)
+        bounds = np.zeros((self.steps, self.n_edges), np.float64)
+        for start, end in zip(self.change_steps, self.change_steps[1:] + [self.steps]):
+            bounds[start:end] = self.capacity_at(start)
+        with np.errstate(invalid="ignore", divide="ignore"):
+            return np.where(bounds[:, :, None] > 0, load / bounds[:, :, None], np.nan)
+
+    @cached_property
+    def field_snapshots(self) -> pd.DataFrame:
+        return self.telemetry("potential_field")
+
+    def field(self, step: int) -> np.ndarray:
+        """Stored potential of the tracked flows at a logged step: (tracked_flows, n_nodes)."""
+        row = self.field_snapshots[self.field_snapshots.step == step]
+        if row.empty:
+            raise KeyError(f"step {step} is not logged; logged steps are multiples of {self.field_stride}")
+        return np.asarray(row.potential.iloc[0], np.float64).reshape(self.tracked_flows, self.n_nodes)
+
+    def nearest_logged_step(self, step: int) -> int:
+        return int(min(self.field_snapshots.step, key=lambda s: abs(s - step)))
+
+    def solve_field(self, step: int, queue: Optional[np.ndarray] = None, flows: Optional[Sequence[int]] = None) -> np.ndarray:
+        """Recompute the potential of any flows at any step from the graph state and queue depths.
+
+        Uses the generator's own engine (grounded Laplacian via the pseudo-inverse); with the
+        potential router's queue depths at `step` this reproduces ``field(step)`` to floating-point
+        precision. Returns (len(flows), n_nodes); flows default to the tracked ones.
+        """
+        if queue is None:
+            queue = self.queue_depth("potential")[step]
+        flows = np.arange(self.tracked_flows) if flows is None else np.asarray(flows)
+        cfg = self.config
+        field = PotentialField(self.live_graph(step), self.source[flows], self.sink[flows], cfg.source_injection)
+        injection = cfg.background_injection / (self.n_nodes - 1) + cfg.congestion_gain * np.asarray(queue, np.float64) / cfg.buffer_size
+        return field.solve(injection)
+
+    def next_hops(self, step: int, phi: np.ndarray) -> np.ndarray:
+        """Steepest-current next hop of every node for the given potentials (flows, n_nodes); −1 at the sink."""
+        g = self.live_graph(step)
+        return steepest_next_hops(currents(phi, g), g)
+
+    def descent_path(self, step: int, phi: np.ndarray, source: int, sink: int) -> List[int]:
+        """Follow the steepest-current next hops of one potential vector (n_nodes,) from source to sink."""
+        hops = self.next_hops(step, np.asarray(phi, np.float64)[None, :])[0]
+        node, path = int(source), [int(source)]
+        while node != int(sink):
+            node = int(hops[node])
+            if node < 0 or len(path) > self.n_nodes:
+                raise RuntimeError("descent did not reach the sink")
+            path.append(node)
+        return path

src/design.py

@@ -0,0 +1,104 @@
+"""Experimental design of the dataset.
+
+Every episode belongs to one *cell* of a full factorial design over five factors:
+
+    topology family × nominal size × traffic profile × load level × dynamics level
+
+Episode ``e`` maps deterministically to cell ``e mod n_cells`` and replicate ``e div n_cells``, so any
+prefix of the episode range — and therefore any partially generated or resumed dataset — covers
+all cells evenly. Replicates are assigned to train / validation / test splits (60 / 20 / 20).
+The level definitions below are the design; ``SimConfig`` selects which levels to generate.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from itertools import product
+from typing import Dict, List, Tuple
+
+TOPOLOGIES = ("barabasi_albert", "watts_strogatz", "erdos_renyi", "waxman", "fat_tree")
+SIZES = (32, 64, 128, 256)          # nominal node count (fat-tree: k = 4, 6, 8, 10 → 36, 99, 208, 375 nodes)
+SPLITS = ("train", "train", "train", "validation", "test")   # by replicate mod 5
+
+
+@dataclass(frozen=True)
+class TrafficProfile:
+    """Two-state Markov-modulated Poisson process, parameterised by its mean rate m.
+
+    With burst duty cycle d = mean_burst_steps / (mean_idle_steps + mean_burst_steps):
+    idle_rate = m / ((1 − d) + d · peak_ratio),  burst_rate = peak_ratio · idle_rate,
+    so the long-run mean rate equals m for every profile.
+    """
+    peak_ratio: float          # burst_rate / idle_rate (1 = stationary Poisson)
+    mean_idle_steps: float
+    mean_burst_steps: float
+
+    @property
+    def duty(self) -> float:
+        return self.mean_burst_steps / (self.mean_idle_steps + self.mean_burst_steps)
+
+    def rates(self, mean_rate: float) -> Tuple[float, float]:
+        idle = mean_rate / ((1.0 - self.duty) + self.duty * self.peak_ratio)
+        return idle, self.peak_ratio * idle
+
+
+TRAFFIC_PROFILES: Dict[str, TrafficProfile] = {
+    "poisson": TrafficProfile(peak_ratio=1.0, mean_idle_steps=100.0, mean_burst_steps=100.0),
+    "microburst": TrafficProfile(peak_ratio=16.0, mean_idle_steps=100.0, mean_burst_steps=15.0),
+    "sustained": TrafficProfile(peak_ratio=4.0, mean_idle_steps=100.0, mean_burst_steps=100.0),
+}
+
+# Offered load ρ = Σ_f m_f · hops_f / Σ_links capacity: the fraction of the network's directed link
+# capacity that the flows would occupy on their shortest paths. Per-flow mean rates m_f are log-normal
+# (σ = 0.75, "elephants and mice") and rescaled so that every episode meets its level exactly.
+LOAD_LEVELS: Dict[str, float] = {
+    "light": 0.01,
+    "moderate": 0.03,
+    "heavy": 0.10,
+}
+RATE_SIGMA = 0.75
+
+
+@dataclass(frozen=True)
+class Dynamics:
+    link_failure_rate: float         # per-step probability that a non-bridge link fails
+    node_degradation_rate: float     # per-step probability that a node degrades
+    duration_range: Tuple[int, int]  # event duration, steps
+    factor_range: Tuple[float, float]  # capacity multiplier of a degraded node's links
+
+
+DYNAMICS_LEVELS: Dict[str, Dynamics] = {
+    "static": Dynamics(0.0, 0.0, (0, 0), (1.0, 1.0)),
+    "moderate": Dynamics(0.002, 0.002, (50, 200), (0.1, 0.5)),
+    "severe": Dynamics(0.01, 0.01, (100, 400), (0.1, 0.5)),
+}
+
+
+@dataclass(frozen=True)
+class Cell:
+    topology: str
+    size: int
+    traffic_profile: str
+    load_level: str
+    dynamics_level: str
+
+    @property
+    def profile(self) -> TrafficProfile:
+        return TRAFFIC_PROFILES[self.traffic_profile]
+
+    @property
+    def load(self) -> float:
+        return LOAD_LEVELS[self.load_level]
+
+    @property
+    def dynamics(self) -> Dynamics:
+        return DYNAMICS_LEVELS[self.dynamics_level]
+
+
+def cells(topologies, sizes, traffic_profiles, load_levels, dynamics_levels) -> List[Cell]:
+    return [Cell(*levels) for levels in product(topologies, sizes, traffic_profiles, load_levels, dynamics_levels)]
+
+
+def locate(episode_id: int, n_cells: int) -> Tuple[int, int, str]:
+    """(cell index, replicate, split) of an episode."""
+    replicate = episode_id // n_cells
+    return episode_id % n_cells, replicate, SPLITS[replicate % len(SPLITS)]

src/graph_generator.py

@@ -0,0 +1,203 @@
+"""Topology families and dynamic-topology timelines.
+
+Five families span the structures routing research cares about: Barabási–Albert scale-free
+graphs (router-level Internet), Watts–Strogatz small worlds, Erdős–Rényi random graphs, Waxman
+geometric graphs (ISP-like, with distance-proportional latencies and node coordinates) and k-ary
+fat-trees (data-centre fabrics whose hosts are the only traffic endpoints; host links carry twice
+the fabric capacity, i.e. a 2:1 oversubscribed edge, so bursts contend inside the fabric). Random families are
+generated at a common mean degree so that size is the only structural factor that changes with
+the nominal network size; any rare disconnected sample is stitched into one component instead of
+being resampled, so the node count is always exactly the nominal one.
+
+A pre-sampled timeline of link failures and node degradations makes the graph time-varying.
+Failures are drawn only from non-bridge links of the currently live graph, so the network never
+partitions and traffic can always be routed around the damage.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Tuple
+
+import networkx as nx
+import numpy as np
+
+from .config import SimConfig
+from .design import Cell, Dynamics
+
+ROLE_ROUTER, ROLE_CORE, ROLE_AGGREGATION, ROLE_EDGE, ROLE_HOST = 0, 1, 2, 3, 4
+
+
+@dataclass(frozen=True)
+class Topology:
+    n_nodes: int
+    edges: np.ndarray      # (E, 2) int16, each row (u, v) with u < v, lexicographically sorted
+    capacity: np.ndarray   # (E,) int16 packets/step per direction
+    latency: np.ndarray    # (E,) int16 steps
+    endpoints: np.ndarray  # (K,) int16 nodes eligible as flow sources and sinks
+    node_role: np.ndarray  # (N,) int8, ROLE_* constants
+    node_xy: np.ndarray    # (N, 2) float32 coordinates, or shape (0, 2) for non-geometric families
+
+
+@dataclass(frozen=True)
+class TopologyEvent:
+    kind: str            # "link_failure" | "node_degradation"
+    start: int           # first step the event is active
+    end: int             # first step it is no longer active (exclusive)
+    edge: int = -1       # index into Topology.edges for a link failure
+    node: int = -1       # degraded node
+    factor: float = 0.0  # capacity multiplier applied to the degraded node's links
+
+
+def _stitch(graph: nx.Graph, xy: np.ndarray = None, rng: np.random.Generator = None) -> None:
+    """Connect a disconnected graph by joining every component to the largest one (rare)."""
+    components = sorted(nx.connected_components(graph), key=len, reverse=True)
+    main = np.array(sorted(components[0]))
+    for comp in components[1:]:
+        comp = np.array(sorted(comp))
+        if xy is not None:  # geometric: closest pair of nodes
+            d = np.linalg.norm(xy[comp][:, None, :] - xy[main][None, :, :], axis=2)
+            a, b = np.unravel_index(int(d.argmin()), d.shape)
+            graph.add_edge(int(comp[a]), int(main[b]))
+        else:
+            graph.add_edge(int(rng.choice(comp)), int(rng.choice(main)))
+        main = np.concatenate([main, comp])
+
+
+def _random_family(cfg: SimConfig, family: str, n: int, rng: np.random.Generator):
+    seed = int(rng.integers(2**31 - 1))
+    xy = np.zeros((0, 2), np.float32)
+    if family == "barabasi_albert":
+        graph = nx.barabasi_albert_graph(n, cfg.mean_degree // 2, seed=seed)
+    elif family == "watts_strogatz":
+        graph = nx.connected_watts_strogatz_graph(n, cfg.mean_degree, 0.1, tries=1000, seed=seed)
+    elif family == "erdos_renyi":
+        graph = nx.gnp_random_graph(n, cfg.mean_degree / (n - 1), seed=seed)
+        _stitch(graph, rng=rng)
+    elif family == "waxman":
+        xy = rng.random((n, 2)).astype(np.float32)
+        iu, iv = np.triu_indices(n, 1)
+        d = np.linalg.norm(xy[iu] - xy[iv], axis=1)
+        kernel = np.exp(-d / (0.15 * np.sqrt(2.0)))   # Waxman link preference, alpha = 0.15 of the diagonal
+        n_edges = round(0.5 * cfg.mean_degree * n)     # fixed edge count: exact mean degree at every size
+        chosen = rng.choice(len(iu), n_edges, replace=False, p=kernel / kernel.sum())
+        graph = nx.Graph()
+        graph.add_nodes_from(range(n))
+        graph.add_edges_from(zip(iu[chosen].tolist(), iv[chosen].tolist()))
+        _stitch(graph, xy=xy)
+    else:
+        raise ValueError(family)
+    edges = np.sort(np.array(graph.edges(), dtype=np.int16), axis=1)
+    edges = edges[np.lexsort((edges[:, 1], edges[:, 0]))]
+    lo, hi = cfg.capacity_range
+    capacity = rng.integers(lo, hi + 1, len(edges)).astype(np.int16)
+    if family == "waxman":  # latency proportional to Euclidean distance, spanning latency_range
+        lo_l, hi_l = cfg.latency_range
+        dist = np.linalg.norm(xy[edges[:, 0]] - xy[edges[:, 1]], axis=1) / np.sqrt(2.0)
+        latency = np.round(lo_l + (hi_l - lo_l) * dist).astype(np.int16)
+    else:
+        lo_l, hi_l = cfg.latency_range
+        latency = rng.integers(lo_l, hi_l + 1, len(edges)).astype(np.int16)
+    return Topology(n, edges, capacity, latency, np.arange(n, dtype=np.int16),
+                    np.zeros(n, np.int8), xy)
+
+
+def fat_tree_k(nominal_size: int) -> int:
+    """Fat-tree arity for a nominal size: k = 4, 6, 8, 10 give 36, 99, 208, 375 nodes."""
+    return {32: 4, 64: 6, 128: 8, 256: 10}.get(nominal_size, 2 * max(2, round((nominal_size / 4) ** (1 / 3))))
+
+
+def _fat_tree(cfg: SimConfig, nominal_size: int) -> Topology:
+    k = fat_tree_k(nominal_size)
+    half = k // 2
+    n_core = half * half
+
+    def core(i, j):
+        return i * half + j
+
+    def agg(pod, i):
+        return n_core + pod * k + i
+
+    def edge(pod, i):
+        return n_core + pod * k + half + i
+
+    def host(pod, i, h):
+        return n_core + k * k + (pod * half + i) * half + h
+
+    links = []
+    for pod in range(k):
+        for i in range(half):
+            for j in range(half):
+                links.append((core(i, j), agg(pod, i)))
+                links.append((agg(pod, i), edge(pod, j)))
+            for h in range(half):
+                links.append((edge(pod, i), host(pod, i, h)))
+    n = n_core + k * k + k * half * half
+    edges = np.sort(np.array(links, dtype=np.int16), axis=1)
+    edges = edges[np.lexsort((edges[:, 1], edges[:, 0]))]
+    role = np.full(n, ROLE_HOST, np.int8)
+    role[:n_core] = ROLE_CORE
+    for pod in range(k):
+        role[agg(pod, 0):agg(pod, 0) + half] = ROLE_AGGREGATION
+        role[edge(pod, 0):edge(pod, 0) + half] = ROLE_EDGE
+    hosts = np.flatnonzero(role == ROLE_HOST).astype(np.int16)
+    host_link = (role[edges[:, 0]] == ROLE_HOST) | (role[edges[:, 1]] == ROLE_HOST)
+    capacity = np.where(host_link, 2 * cfg.fat_tree_capacity, cfg.fat_tree_capacity).astype(np.int16)
+    return Topology(n, edges, capacity, np.ones(len(edges), np.int16), hosts, role, np.zeros((0, 2), np.float32))
+
+
+def generate_topology(cfg: SimConfig, cell: Cell, rng: np.random.Generator) -> Topology:
+    if cell.topology == "fat_tree":
+        return _fat_tree(cfg, cell.size)
+    return _random_family(cfg, cell.topology, cell.size, rng)
+
+
+def effective_capacity(topo: Topology, events: List[TopologyEvent], step: int) -> np.ndarray:
+    """Per-link capacity in force at `step`: base × degradation factors of both endpoints, 0 if failed."""
+    failed = np.zeros(len(topo.edges), bool)
+    factor = np.ones(topo.n_nodes)
+    for ev in events:
+        if ev.start <= step < ev.end:
+            if ev.kind == "link_failure":
+                failed[ev.edge] = True
+            else:
+                factor[ev.node] *= ev.factor
+    u, v = topo.edges.T
+    cap = np.maximum(1, np.floor(topo.capacity * factor[u] * factor[v])).astype(np.int16)
+    cap[failed] = 0
+    return cap
+
+
+def generate_timeline(cfg: SimConfig, topo: Topology, dyn: Dynamics, rng: np.random.Generator
+                      ) -> Tuple[List[TopologyEvent], List[Tuple[int, np.ndarray]]]:
+    """Pre-sample every topology event of an episode.
+
+    Returns ``(events, changes)`` where ``changes`` lists the ``(step, effective_capacity)`` pairs
+    at which link capacities change, starting with ``(0, base capacities)``.
+    """
+    fail_at = rng.random(cfg.steps) < dyn.link_failure_rate
+    degrade_at = rng.random(cfg.steps) < dyn.node_degradation_rate
+    lo_d, hi_d = dyn.duration_range
+    lo_f, hi_f = dyn.factor_range
+    events: List[TopologyEvent] = []
+    all_edges = [tuple(e) for e in topo.edges.tolist()]
+
+    for t in range(cfg.steps):
+        if fail_at[t]:
+            down = {ev.edge for ev in events if ev.kind == "link_failure" and ev.start <= t < ev.end}
+            live = nx.Graph()
+            live.add_nodes_from(range(topo.n_nodes))
+            live.add_edges_from(e for i, e in enumerate(all_edges) if i not in down)
+            bridges = {tuple(sorted(b)) for b in nx.bridges(live)}
+            candidates = [i for i, e in enumerate(all_edges) if i not in down and e not in bridges]
+            if candidates:
+                end = min(t + int(rng.integers(lo_d, hi_d + 1)), cfg.steps)
+                events.append(TopologyEvent("link_failure", t, end, edge=int(rng.choice(candidates))))
+        if degrade_at[t]:
+            end = min(t + int(rng.integers(lo_d, hi_d + 1)), cfg.steps)
+            events.append(TopologyEvent("node_degradation", t, end,
+                                        node=int(rng.integers(topo.n_nodes)),
+                                        factor=float(rng.uniform(lo_f, hi_f))))
+
+    steps = {0} | {ev.start for ev in events} | {ev.end for ev in events if ev.end < cfg.steps}
+    changes = [(t, effective_capacity(topo, events, t)) for t in sorted(steps)]
+    return events, changes

src/physics_engine.py

@@ -0,0 +1,224 @@
+"""Training-free potential-field routing on the graph Laplacian, and the classical baselines.
+
+For flow *f* with source *s* and sink *t* the potential φ solves the discrete Poisson equation
+
+    L_g φ = b,      L = D − W,      w_ij = capacity_ij / latency_ij   (live links only)
+
+where L_g is the Laplacian with the sink's row and column removed, i.e. the Dirichlet boundary
+condition φ_t = 0: the sink is the grounded, attractive well of the field. The right-hand side
+injects a unit current at the source, a small positive background at every node and a repulsive
+current proportional to each node's buffer occupancy.
+
+The grounded inverse is available in closed form from the Laplacian pseudo-inverse L⁺:
+(L_g⁻¹)_ij = L⁺_ij − L⁺_it − L⁺_tj + L⁺_tt. Because the background and congestion injections are
+the same for every flow, the fields of all F flows follow from one matrix–vector product with L⁺
+plus O(N) work per flow, so L⁺ is formed once per topology change (dense, N ≤ 375) and every step
+costs O(N·F) instead of F sparse solves. ``grounded_solve`` keeps the sparse SuperLU reference
+solution for validation.
+
+Packets follow the routing gradient. On every live directed link the current is
+I_ij = w_ij (φ_i − φ_j); the *steepest* rule forwards along the largest current out of a node and
+the *split* rule sprays packets over the outgoing links in proportion to their positive currents,
+exactly how electrical current divides. Because b_i > 0 at every non-sink node, Σ_j I_ij = b_i > 0,
+so at least one current is positive and every positive-current link leads strictly downhill:
+both rules are loop-free and reach the sink in at most N − 1 hops for any congestion pattern.
+
+The baselines — static shortest path, equal-cost multipath and queue-aware adaptive shortest
+path — share one Dijkstra helper (``scipy.sparse.csgraph.dijkstra`` on the reversed graph, whose
+predecessor tree is exactly the next-hop table towards each sink).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+import scipy.sparse as sp
+from scipy.sparse.csgraph import dijkstra, laplacian
+from scipy.sparse.linalg import splu
+
+GOLDEN = 0.6180339887498949  # low-discrepancy per-packet coordinate for multipath spraying
+
+
+@dataclass(frozen=True)
+class LiveGraph:
+    """Directed view of the links with positive capacity at one point in time, sorted by tail node."""
+    n: int
+    n_edges: int               # E of the base topology
+    src: np.ndarray            # (M,) int32 tail of every live directed link
+    dst: np.ndarray            # (M,) int32 head
+    base: np.ndarray           # (M,) int32 index into the 2E directed base links: edge + E * direction
+    capacity: np.ndarray       # (M,) int32
+    latency: np.ndarray        # (M,) int32
+    conductance: np.ndarray    # (M,) float64
+    indptr: np.ndarray         # (n + 1,) segment boundaries of each tail node
+    dir_edge: np.ndarray       # (n, n) int32 live directed link index, −1 where there is none
+
+    @property
+    def degree(self) -> np.ndarray:
+        return np.diff(self.indptr)
+
+    @property
+    def max_degree(self) -> int:
+        return int(self.degree.max())
+
+    def laplacian(self) -> np.ndarray:
+        weights = sp.csr_matrix((self.conductance, (self.src, self.dst)), shape=(self.n, self.n))
+        return laplacian(weights).toarray()
+
+
+def live_graph(n: int, edges: np.ndarray, capacity: np.ndarray, latency: np.ndarray) -> LiveGraph:
+    n_edges = len(edges)
+    live = np.flatnonzero(capacity > 0)
+    u, v = edges[live, 0].astype(np.int32), edges[live, 1].astype(np.int32)
+    src = np.concatenate([u, v])
+    dst = np.concatenate([v, u])
+    base = np.concatenate([live, live + n_edges]).astype(np.int32)
+    order = np.lexsort((dst, src))
+    src, dst, base = src[order], dst[order], base[order]
+    cap = capacity[base % n_edges].astype(np.int32)
+    lat = latency[base % n_edges].astype(np.int32)
+    indptr = np.searchsorted(src, np.arange(n + 1))
+    dir_edge = np.full((n, n), -1, np.int32)
+    dir_edge[src, dst] = np.arange(len(src))
+    return LiveGraph(n, n_edges, src, dst, base, cap, lat, cap / lat, indptr, dir_edge)
+
+
+class PotentialField:
+    """Grounded-Laplacian Green's functions of every flow, from one dense pseudo-inverse."""
+
+    def __init__(self, g: LiveGraph, sources: np.ndarray, sinks: np.ndarray, source_injection: float):
+        n = g.n
+        pinv = np.linalg.inv(g.laplacian() + 1.0 / n) - 1.0 / n        # L⁺ = (L + J/N)⁻¹ − J/N
+        self.pinv = 0.5 * (pinv + pinv.T)                                # exactly symmetric, like L⁺ itself
+        self.sinks = np.asarray(sinks, np.intp)
+        self.flow_ids = np.arange(len(self.sinks))
+        s, t = np.asarray(sources, np.intp), self.sinks
+        self.row_t = self.pinv[t]                                        # (F, N) rows L⁺_t·
+        self.diag_t = self.pinv[t, t]                                    # (F,)
+        # Response to the unit source injection, G^(t) e_s, zero at the sink by construction.
+        self.source_term = source_injection * (self.pinv[s] - self.row_t
+                                               - self.pinv[t, s][:, None] + self.diag_t[:, None])
+
+    def solve(self, injection: np.ndarray) -> np.ndarray:
+        """Per-node injection shared by all flows (N,) → potentials φ (F, N) with φ[f, sink_f] = 0."""
+        p = self.pinv @ injection
+        total = injection.sum()
+        # (G^(t) c)_i = p_i − L⁺_it·Σc − (p_t − L⁺_tt·Σc); the injection at the grounded sink cancels.
+        phi = p[None, :] - self.row_t * total - (p[self.sinks] - self.diag_t * total)[:, None] + self.source_term
+        phi[self.flow_ids, self.sinks] = 0.0                            # exact ground, free of rounding residue
+        return phi
+
+
+def grounded_solve(g: LiveGraph, sink: int, b: np.ndarray) -> np.ndarray:
+    """Reference sparse solution of L_g φ = b for one sink (SuperLU); used for validation."""
+    keep = np.delete(np.arange(g.n), sink)
+    lap = sp.csr_matrix(g.laplacian())
+    phi = np.zeros(g.n)
+    phi[keep] = splu(lap[keep][:, keep].tocsc()).solve(b[keep])
+    return phi
+
+
+def currents(phi: np.ndarray, g: LiveGraph) -> np.ndarray:
+    """I_ij = w_ij (φ_i − φ_j) on every live directed link, shape (F, M)."""
+    return (np.take(phi, g.src, axis=1) - np.take(phi, g.dst, axis=1)) * g.conductance
+
+
+TIE_TOLERANCE = 1e-9  # currents within this relative margin of a node's largest current count as tied
+
+
+def steepest_next_hops(cur: np.ndarray, g: LiveGraph) -> np.ndarray:
+    """Next hop per (flow, node): the link carrying the largest current; −1 if none is positive.
+
+    Symmetric topologies produce mathematically equal currents on parallel links; ties are resolved
+    towards the first link in tail-node order within a relative tolerance far above rounding noise,
+    so the choice does not depend on the last bits of the linear algebra on a given platform.
+    """
+    starts = g.indptr[:-1]
+    best = np.maximum.reduceat(cur, starts, axis=1)                                # (F, N)
+    tied = cur >= np.take(best, g.src, axis=1) * (1.0 - TIE_TOLERANCE)
+    first = np.where(tied, np.arange(len(g.src)), len(g.src))
+    k = np.minimum.reduceat(first, starts, axis=1)                                 # (F, N)
+    return np.where(best > 0, g.dst[np.minimum(k, len(g.src) - 1)], -1).astype(np.int16)
+
+
+def spray_next_hops(cur: np.ndarray, g: LiveGraph, node: np.ndarray, flow: np.ndarray,
+                    packet_id: np.ndarray) -> np.ndarray:
+    """Per-packet next hop drawn in proportion to the positive currents leaving the packet's node.
+
+    Packets are grouped by (flow, node); each group's outgoing shares form a cumulative
+    distribution, all groups are laid out as one monotone array (group index doubled plus CDF),
+    and every packet's low-discrepancy coordinate is placed with a single ``searchsorted``.
+    """
+    key = flow.astype(np.int64) * g.n + node
+    order = np.argsort(key, kind="stable")
+    sorted_key = key[order]
+    starts = np.flatnonzero(np.r_[True, sorted_key[1:] != sorted_key[:-1]])
+    group = np.repeat(np.arange(len(starts)), np.diff(np.r_[starts, len(order)]))
+    g_flow, g_node = flow[order][starts].astype(np.int64), node[order][starts].astype(np.int64)
+    degree = g.degree[g_node]
+    width = int(degree.max())
+    slot = np.arange(width)
+    valid = slot[None, :] < degree[:, None]                                         # (G, width)
+    link = np.minimum(g.indptr[g_node][:, None] + slot[None, :], len(g.src) - 1)
+    share = np.where(valid, np.maximum(cur[g_flow[:, None], link], 0.0), 0.0)
+    cdf = np.cumsum(share, axis=1)
+    total = cdf[:, -1]
+    ok = total > 0
+    cdf = np.where(valid & ok[:, None], cdf / np.where(ok, total, 1.0)[:, None], 1.0)  # exact 1.0 at the last link
+    augmented = (cdf + 2.0 * np.arange(len(starts))[:, None]).ravel()
+    u = (packet_id[order] * GOLDEN) % 1.0
+    pick = np.searchsorted(augmented, 2.0 * group + u, side="right") - group * width
+    hop = np.where(ok[group], g.dst[g.indptr[g_node[group]] + pick], -1)
+    out = np.empty(len(order), np.int16)
+    out[order] = hop
+    return out
+
+
+COST_QUANTUM = 1e-6  # adaptive link costs are rounded to this many steps so that path sums are exact integers
+
+
+def dijkstra_next_hops(cost: np.ndarray, g: LiveGraph, sinks: np.ndarray):
+    """Shortest paths to each sink under per-directed-link costs: (next_hop (D, N), dist (D, N)).
+
+    Costs must be integer-valued floats (latencies, or quantised adaptive costs) so that every
+    path sum is exact. Distances then do not depend on the solver's tie-breaking, and the next hop
+    is derived from them here — the first link, in tail-node order, that lies on a shortest path —
+    which keeps the tables identical across SciPy versions and platforms.
+    """
+    reverse = sp.csr_matrix((cost, (g.dst, g.src)), shape=(g.n, g.n))  # reverse[j, i] = cost(i → j)
+    dist = dijkstra(reverse, directed=True, indices=np.asarray(sinks, np.intp))
+    starts = g.indptr[:-1]
+    through = np.take(dist, g.dst, axis=1) + cost                                # (D, M)
+    first = np.where(through == np.take(dist, g.src, axis=1), np.arange(len(g.src)), len(g.src))
+    k = np.minimum.reduceat(first, starts, axis=1)                                # (D, N)
+    next_hop = g.dst[np.minimum(k, len(g.src) - 1)].astype(np.int16)
+    next_hop[np.arange(len(sinks)), np.asarray(sinks, np.intp)] = -1
+    return next_hop, dist
+
+
+class EcmpTable:
+    """All equal-latency next hops per (sink, node); packets are sprayed round-robin over them."""
+
+    def __init__(self, dist: np.ndarray, g: LiveGraph):
+        starts = g.indptr[:-1]
+        equal = np.take(dist, g.dst, axis=1) + g.latency == np.take(dist, g.src, axis=1)   # (D, M)
+        self.count = np.add.reduceat(equal.astype(np.int32), starts, axis=1)             # (D, N)
+        csum = np.cumsum(equal, axis=1)
+        pos = csum - np.take(csum[:, starts] - equal[:, starts], g.src, axis=1) - 1
+        self.table = np.full((dist.shape[0], g.n, g.max_degree), -1, np.int16)
+        rows, cols = np.nonzero(equal)
+        self.table[rows, g.src[cols], pos[rows, cols]] = g.dst[cols]
+
+    def hops(self, sink_index: np.ndarray, node: np.ndarray, packet_id: np.ndarray) -> np.ndarray:
+        count = self.count[sink_index, node]
+        return self.table[sink_index, node, packet_id % np.maximum(count, 1)]  # −1 where count is 0
+
+
+def path_metrics(g: LiveGraph, sources: np.ndarray, sinks: np.ndarray):
+    """Minimum hop count and minimum latency from every flow's source to its sink."""
+    origins, index = np.unique(np.asarray(sources, np.intp), return_inverse=True)
+    hops = dijkstra(sp.csr_matrix((np.ones(len(g.src)), (g.src, g.dst)), shape=(g.n, g.n)),
+                    directed=True, indices=origins)
+    lat = dijkstra(sp.csr_matrix((g.latency.astype(np.float64), (g.src, g.dst)), shape=(g.n, g.n)),
+                   directed=True, indices=origins)
+    return hops[index, sinks].astype(np.int16), lat[index, sinks].astype(np.int16)

src/simulation_loop.py

@@ -0,0 +1,451 @@
+"""Monte Carlo episodes: MMPP traffic through a packet-level queueing network under six routers.
+
+One episode samples a topology from its design cell, the failure/degradation timeline, F flows
+between distinct ordered (source, sink) pairs whose mean rates realise the cell's offered load,
+and each flow's Markov-modulated Poisson arrival stream. That identical scenario is then replayed
+under every router, so any difference between routers is attributable to the routing policy
+alone. The queueing model is deliberately explicit:
+
+* every node owns one drop-tail FIFO buffer of ``buffer_size`` packets shared by all flows;
+* every directed link forwards at most ``capacity`` packets per step, taking the oldest packets at
+  its tail whose next hop crosses it (virtual output queueing, no head-of-line blocking);
+* a packet forwarded at step t over a link of latency ℓ reaches the head node at step t + ℓ, where
+  it is delivered (its flow's sink), admitted, or dropped if the buffer is full;
+* routing decisions are recomputed every step (potential, potential_split, adaptive_shortest_path)
+  or at every topology change (potential_static, shortest_path, ecmp).
+
+Every step is vectorised with NumPy over the packets in flight; episodes are mapped across CPU
+cores with ``multiprocessing.Pool`` and streamed to Parquet shard by shard.
+"""
+from __future__ import annotations
+
+import multiprocessing as mp
+import time
+from dataclasses import dataclass
+from functools import partial
+from pathlib import Path
+from typing import Dict, List
+
+import numpy as np
+import pyarrow as pa
+
+from .config import SimConfig
+from .design import RATE_SIGMA, Cell, TrafficProfile, locate
+from .graph_generator import Topology, TopologyEvent, generate_timeline, generate_topology
+from .physics_engine import (COST_QUANTUM, EcmpTable, LiveGraph, PotentialField, currents,
+                             dijkstra_next_hops, live_graph, path_metrics, spray_next_hops,
+                             steepest_next_hops)
+from .telemetry_logger import SCHEMAS, completed_shards, list_column, write_shard
+
+FIELD_ROUTER = "potential"  # the router whose potential field is stored
+
+
+@dataclass(frozen=True)
+class Flows:
+    source: np.ndarray       # (F,) int16
+    sink: np.ndarray         # (F,) int16
+    mean_rate: np.ndarray    # (F,) float32 long-run packets/step
+    idle_rate: np.ndarray    # (F,) float32
+    burst_rate: np.ndarray   # (F,) float32
+    min_hops: np.ndarray     # (F,) int16 on the base topology
+    min_latency: np.ndarray  # (F,) int16 on the base topology
+    total_capacity: float    # Σ over directed base links of capacity, packets/step
+
+
+def sample_flows(cfg: SimConfig, cell: Cell, topo: Topology, base: LiveGraph,
+                 rng: np.random.Generator) -> Flows:
+    endpoints = topo.endpoints
+    k = len(endpoints)
+    n_flows = cfg.flows_per_endpoint * k
+    pair = rng.choice(k * (k - 1), n_flows, replace=False)          # distinct ordered pairs
+    si, ti = pair // (k - 1), pair % (k - 1)
+    ti = ti + (ti >= si)
+    source, sink = endpoints[si], endpoints[ti]
+    min_hops, min_latency = path_metrics(base, source, sink)
+    weight = np.exp(RATE_SIGMA * rng.standard_normal(n_flows))        # elephants and mice
+    total_capacity = float(base.capacity.sum())
+    mean = cell.load * total_capacity * weight / float(weight @ min_hops)
+    idle, burst = cell.profile.rates(mean)
+    return Flows(source, sink, mean.astype(np.float32), idle.astype(np.float32),
+                 burst.astype(np.float32), min_hops, min_latency, total_capacity)
+
+
+def sample_mmpp(cfg: SimConfig, profile: TrafficProfile, flows: Flows, rng: np.random.Generator):
+    """Two-state MMPP per flow: (state (F, T) int8 with 1 = burst, arrivals (F, T) int32)."""
+    n_flows = len(flows.source)
+    state = np.zeros((n_flows, cfg.steps), np.int8)
+    if profile.peak_ratio > 1.0:
+        p_ib, p_bi = 1.0 / profile.mean_idle_steps, 1.0 / profile.mean_burst_steps
+        state[:, 0] = rng.random(n_flows) < profile.duty  # stationary start
+        u = rng.random((n_flows, cfg.steps))
+        for t in range(1, cfg.steps):
+            idle = state[:, t - 1] == 0
+            state[:, t] = np.where(idle, u[:, t] < p_ib, u[:, t] >= p_bi)
+    rate = np.where(state == 1, flows.burst_rate[:, None], flows.idle_rate[:, None])
+    return state, rng.poisson(rate).astype(np.int32)
+
+
+def _rank_within_groups(sorted_keys: np.ndarray) -> np.ndarray:
+    """Position of every element inside its run of equal keys (keys must be sorted)."""
+    n = len(sorted_keys)
+    starts = np.flatnonzero(np.r_[True, sorted_keys[1:] != sorted_keys[:-1]])
+    return np.arange(n) - np.repeat(starts, np.diff(np.r_[starts, n]))
+
+
+@dataclass
+class RouterRun:
+    queue: np.ndarray            # (T, N) int16 buffer occupancy after admission, before forwarding
+    node_drops: np.ndarray       # (T, N) int16 packets dropped at each node this step
+    link_load: np.ndarray        # (T, 2E) int16 packets forwarded over each directed base link
+    potential: np.ndarray        # (S, tracked, N) float32 field snapshots every `stride` steps, or None
+    per_flow: Dict[str, np.ndarray]  # (T, F) int32: admitted, delivered, dropped, queued, in_transit, route_changes
+    delay_sum: np.ndarray        # (T, F) sum of end-to-end delays of packets delivered this step
+    in_flight: np.ndarray        # (F,) packets still queued or on a link when the episode ends
+    delays: List[np.ndarray]     # per flow, end-to-end delay of every delivered packet
+    propagation: List[np.ndarray]  # per flow, propagation part of that delay
+    hops: List[np.ndarray]       # per flow, hop count of every delivered packet
+    utilisation: float           # packets forwarded / directed link capacity, over all link-steps
+    saturation: float            # fraction of directed link-steps forwarding at full capacity
+
+
+def run_router(cfg: SimConfig, topo: Topology, flows: Flows, arrivals: np.ndarray,
+               changes: list, router: str, field_stride: int) -> RouterRun:
+    n, n_flows, steps, buffer = topo.n_nodes, len(flows.source), cfg.steps, cfg.buffer_size
+    n_edges = len(topo.edges)
+    source, sink = flows.source, flows.sink
+    flow_ids = np.arange(n_flows)
+    sinks, sink_index = np.unique(sink, return_inverse=True)          # per-sink tables serve every flow
+    background = cfg.background_injection / (n - 1)
+    tracked = min(cfg.tracked_flows, n_flows)
+    field_based = router in ("potential", "potential_split", "potential_static")
+    per_step = router in ("potential", "potential_split", "adaptive_shortest_path")
+
+    # Packets in flight as a structure of arrays.
+    p_flow = np.zeros(0, np.int16)
+    p_birth = np.zeros(0, np.int32)
+    p_node = np.zeros(0, np.int16)
+    p_ready = np.zeros(0, np.int32)  # step at which the packet is (or becomes) available at p_node
+    p_prop = np.zeros(0, np.int32)   # propagation delay accumulated so far
+    p_hops = np.zeros(0, np.int16)
+    p_id = np.zeros(0, np.int64)     # global creation order: FIFO tie-break and spraying coordinate
+    next_id = 0
+
+    queue_log = np.zeros((steps, n), np.int16)
+    drop_log = np.zeros((steps, n), np.int16)
+    link_log = np.zeros((steps, 2 * n_edges), np.int16)
+    phi_log = (np.zeros((-(-steps // field_stride), tracked, n), np.float32)
+               if router == FIELD_ROUTER else None)
+    per_flow = {k: np.zeros((steps, n_flows), np.int32) for k in
+                ("admitted", "delivered", "dropped", "queued", "in_transit", "route_changes")}
+    delay_sum = np.zeros((steps, n_flows), np.float64)
+    done_flow, done_delay, done_prop, done_hops = [], [], [], []
+    util_num = util_den = 0.0
+    saturated = link_steps = 0
+    previous_hops = None
+    change_i = 0
+
+    for t in range(steps):
+        # 1. Topology in force at this step; rebuild the routing state when links change.
+        if change_i < len(changes) and changes[change_i][0] == t:
+            g = live_graph(n, topo.edges, changes[change_i][1], topo.latency)
+            change_i += 1
+            if field_based:
+                field = PotentialField(g, source, sink, cfg.source_injection)
+                if router == "potential_static":
+                    next_hop = steepest_next_hops(currents(field.solve(np.full(n, background)), g), g)
+            elif router in ("shortest_path", "ecmp"):
+                by_sink, dist = dijkstra_next_hops(g.latency.astype(np.float64), g, sinks)
+                next_hop = by_sink[sink_index]
+                if router == "ecmp":
+                    ecmp = EcmpTable(dist, g)
+
+        # 2. New packets appear at their sources.
+        new = arrivals[:, t]
+        n_new = int(new.sum())
+        if n_new:
+            new_flow = np.repeat(flow_ids, new).astype(np.int16)
+            p_flow = np.concatenate([p_flow, new_flow])
+            p_birth = np.concatenate([p_birth, np.full(n_new, t, np.int32)])
+            p_node = np.concatenate([p_node, source[new_flow]])
+            p_ready = np.concatenate([p_ready, np.full(n_new, t, np.int32)])
+            p_prop = np.concatenate([p_prop, np.zeros(n_new, np.int32)])
+            p_hops = np.concatenate([p_hops, np.zeros(n_new, np.int16)])
+            p_id = np.concatenate([p_id, np.arange(next_id, next_id + n_new)])
+            next_id += n_new
+
+        # 3. Packets reaching a node this step: deliver at the sink, otherwise admit (drop-tail).
+        per_flow["admitted"][t] = new
+        arriving = p_ready == t
+        if arriving.any():
+            at_sink = arriving & (p_node == sink[p_flow])
+            remove = at_sink.copy()
+            if at_sink.any():
+                f, d = p_flow[at_sink], (t - p_birth[at_sink]).astype(np.int32)
+                np.add.at(per_flow["delivered"][t], f, 1)
+                np.add.at(delay_sum[t], f, d)
+                done_flow.append(f)
+                done_delay.append(d)
+                done_prop.append(p_prop[at_sink])
+                done_hops.append(p_hops[at_sink])
+            entering = np.flatnonzero(arriving & ~at_sink)
+            if len(entering):
+                space = buffer - np.bincount(p_node[p_ready < t], minlength=n)
+                entering = entering[np.lexsort((p_id[entering], p_node[entering]))]  # per node, oldest first
+                node = p_node[entering]
+                lost = entering[_rank_within_groups(node) >= space[node]]
+                if len(lost):
+                    np.add.at(per_flow["dropped"][t], p_flow[lost], 1)
+                    np.add.at(drop_log[t], p_node[lost], 1)
+                    at_source = lost[p_birth[lost] == t]
+                    per_flow["admitted"][t] -= np.bincount(p_flow[at_source], minlength=n_flows)
+                    remove[lost] = True
+            keep = ~remove
+            p_flow, p_birth, p_node, p_ready = p_flow[keep], p_birth[keep], p_node[keep], p_ready[keep]
+            p_prop, p_hops, p_id = p_prop[keep], p_hops[keep], p_id[keep]
+
+        # 4. Telemetry snapshot of every buffer, then the routing decision.
+        in_buffer = p_ready <= t
+        queue = np.bincount(p_node[in_buffer], minlength=n)
+        queue_log[t] = queue
+        per_flow["queued"][t] = np.bincount(p_flow[in_buffer], minlength=n_flows)
+        per_flow["in_transit"][t] = np.bincount(p_flow[~in_buffer], minlength=n_flows)
+        if per_step:
+            if router == "adaptive_shortest_path":
+                cost = np.round((g.latency + queue[g.src] / g.capacity) / COST_QUANTUM)
+                by_sink, _ = dijkstra_next_hops(cost, g, sinks)
+                next_hop = by_sink[sink_index]
+            else:
+                phi = field.solve(background + cfg.congestion_gain * queue / buffer)
+                cur = currents(phi, g)
+                next_hop = steepest_next_hops(cur, g)
+                if router == FIELD_ROUTER and t % field_stride == 0:
+                    phi_log[t // field_stride] = phi[:tracked]
+        if previous_hops is not None and next_hop is not previous_hops:
+            per_flow["route_changes"][t] = (next_hop != previous_hops).sum(axis=1)
+        previous_hops = next_hop
+
+        # 5. Forwarding: each directed link takes the oldest packets routed over it, up to capacity.
+        idx = np.flatnonzero(in_buffer)
+        if len(idx):
+            node, flow = p_node[idx], p_flow[idx]
+            if router == "potential_split":
+                hop = spray_next_hops(cur, g, node, flow, p_id[idx])
+            elif router == "ecmp":
+                hop = ecmp.hops(sink_index[flow], node, p_id[idx])
+            else:
+                hop = next_hop[flow, node]
+            routable = hop >= 0
+            idx, hop = idx[routable], hop[routable]
+            link = g.dir_edge[p_node[idx], hop]
+            order = np.lexsort((p_id[idx], p_ready[idx], link))
+            idx, link = idx[order], link[order]
+            forward = _rank_within_groups(link) < g.capacity[link]
+            idx, link = idx[forward], link[forward]
+            p_ready[idx] = t + g.latency[link]
+            p_prop[idx] += g.latency[link]
+            p_hops[idx] += 1
+            p_node[idx] = g.dst[link]
+            load = np.bincount(link, minlength=len(g.src))
+            link_log[t] = np.bincount(g.base, weights=load, minlength=2 * n_edges).astype(np.int16)
+            util_num += load.sum()
+            saturated += int((load == g.capacity).sum())
+        util_den += g.capacity.sum()
+        link_steps += len(g.src)
+
+    done_flow = np.concatenate(done_flow) if done_flow else np.zeros(0, np.int16)
+    done_delay = np.concatenate(done_delay) if done_delay else np.zeros(0, np.int32)
+    done_prop = np.concatenate(done_prop) if done_prop else np.zeros(0, np.int32)
+    done_hops = np.concatenate(done_hops) if done_hops else np.zeros(0, np.int16)
+    in_flight = np.bincount(p_flow, minlength=n_flows).astype(np.int32)
+    conserved = per_flow["delivered"].sum(0) + per_flow["dropped"].sum(0) + in_flight
+    assert np.array_equal(arrivals.sum(axis=1), conserved), "packet conservation"
+    order = np.argsort(done_flow, kind="stable")
+    bounds = np.searchsorted(done_flow[order], np.arange(n_flows + 1))
+
+    def by_flow(values: np.ndarray) -> List[np.ndarray]:
+        values = values[order]
+        return [values[bounds[f]:bounds[f + 1]] for f in flow_ids]
+
+    return RouterRun(queue_log, drop_log, link_log, phi_log, per_flow, delay_sum, in_flight,
+                     by_flow(done_delay), by_flow(done_prop), by_flow(done_hops),
+                     util_num / util_den, saturated / link_steps)
+
+
+def field_stride(cfg: SimConfig, n_nodes: int, n_flows: int) -> int:
+    tracked = min(cfg.tracked_flows, n_flows)
+    return max(1, -(-4 * n_nodes * tracked * cfg.steps // cfg.field_budget_bytes))
+
+
+def simulate_episode(cfg: SimConfig, episode_id: int) -> Dict[str, pa.Table]:
+    """Sample one scenario, replay it under every configured router, return its telemetry tables."""
+    cells = cfg.cells
+    cell_index, replicate, split = locate(episode_id, len(cells))
+    cell = cells[cell_index]
+    rng = np.random.default_rng([cfg.seed, episode_id])
+    topo = generate_topology(cfg, cell, rng)
+    base = live_graph(topo.n_nodes, topo.edges, topo.capacity, topo.latency)
+    flows = sample_flows(cfg, cell, topo, base, rng)
+    mmpp_state, arrivals = sample_mmpp(cfg, cell.profile, flows, rng)
+    events, changes = generate_timeline(cfg, topo, cell.dynamics, rng)
+    stride = field_stride(cfg, topo.n_nodes, len(flows.source))
+    runs = {r: run_router(cfg, topo, flows, arrivals, changes, r, stride) for r in cfg.routers}
+    return _episode_tables(cfg, episode_id, cell, cell_index, replicate, split, topo, flows,
+                           mmpp_state, arrivals, events, stride, runs)
+
+
+def _stat(values: List[np.ndarray], fn, empty=np.nan, dtype=np.float32) -> np.ndarray:
+    return np.array([fn(v) if len(v) else empty for v in values], dtype)
+
+
+def _episode_tables(cfg: SimConfig, episode_id: int, cell: Cell, cell_index: int, replicate: int,
+                    split: str, topo: Topology, flows: Flows, mmpp_state: np.ndarray,
+                    arrivals: np.ndarray, events: List[TopologyEvent], stride: int,
+                    runs: Dict[str, RouterRun]) -> Dict[str, pa.Table]:
+    n, n_flows, steps, n_edges = topo.n_nodes, len(flows.source), cfg.steps, len(topo.edges)
+    tracked = min(cfg.tracked_flows, n_flows)
+    step = np.arange(steps, dtype=np.int32)
+    offered = arrivals.sum(axis=1).astype(np.int32)
+    profile = cell.profile
+
+    def ep(size: int) -> np.ndarray:
+        return np.full(size, episode_id, np.int32)
+
+    def text(value: str, size: int) -> pa.Array:
+        return pa.array([value] * size, pa.string())
+
+    tables = {
+        "episodes": pa.table({
+            "episode_id": ep(1), "cell_id": np.array([cell_index], np.int16),
+            "replicate": np.array([replicate], np.int16), "split": [split],
+            "topology": [cell.topology], "size": np.array([cell.size], np.int16),
+            "traffic_profile": [cell.traffic_profile], "load_level": [cell.load_level],
+            "dynamics_level": [cell.dynamics_level],
+            "n_nodes": np.array([n], np.int16), "n_edges": np.array([n_edges], np.int32),
+            "n_flows": np.array([n_flows], np.int16), "tracked_flows": np.array([tracked], np.int16),
+            "steps": np.array([steps], np.int32), "field_stride": np.array([stride], np.int16),
+            "offered_load": np.array([cell.load], np.float32),
+            "total_capacity": np.array([flows.total_capacity], np.float32),
+            "edge_u": [topo.edges[:, 0]], "edge_v": [topo.edges[:, 1]],
+            "capacity": [topo.capacity], "latency": [topo.latency],
+            "node_role": [topo.node_role], "node_x": [topo.node_xy[:, 0]], "node_y": [topo.node_xy[:, 1]],
+            "flow_source": [flows.source], "flow_sink": [flows.sink],
+            "flow_mean_rate": [flows.mean_rate], "flow_idle_rate": [flows.idle_rate],
+            "flow_burst_rate": [flows.burst_rate],
+            "p_idle_to_burst": np.array([1.0 / profile.mean_idle_steps if profile.peak_ratio > 1 else 0.0], np.float32),
+            "p_burst_to_idle": np.array([1.0 / profile.mean_burst_steps if profile.peak_ratio > 1 else 0.0], np.float32),
+        }, schema=SCHEMAS["episodes"]),
+        "events": pa.table({
+            "episode_id": ep(len(events)),
+            "kind": [e.kind for e in events],
+            "start": np.array([e.start for e in events], np.int32),
+            "end": np.array([e.end for e in events], np.int32),
+            "node": np.array([e.node for e in events], np.int16),
+            "edge_u": np.array([topo.edges[e.edge, 0] if e.edge >= 0 else -1 for e in events], np.int16),
+            "edge_v": np.array([topo.edges[e.edge, 1] if e.edge >= 0 else -1 for e in events], np.int16),
+            "factor": np.array([e.factor for e in events], np.float32),
+        }, schema=SCHEMAS["events"]),
+    }
+
+    parts = {name: [] for name in ("router_summary", "flow_summary", "flow_telemetry",
+                                   "network_telemetry", "link_telemetry")}
+    for router, run in runs.items():
+        pf = run.per_flow
+        delivered, dropped = pf["delivered"].sum(0), pf["dropped"].sum(0)
+        all_delays = np.concatenate(run.delays)
+        with np.errstate(invalid="ignore", divide="ignore"):
+            flow_mean_delay = (run.delay_sum / pf["delivered"]).astype(np.float32)
+            step_mean_delay = (run.delay_sum.sum(1) / pf["delivered"].sum(1)).astype(np.float32)
+        parts["router_summary"].append(pa.table({
+            "episode_id": ep(1), "router": [router],
+            "offered": np.array([offered.sum()], np.int32), "delivered": np.array([delivered.sum()], np.int32),
+            "dropped": np.array([dropped.sum()], np.int32), "in_flight": np.array([run.in_flight.sum()], np.int32),
+            "loss_ratio": np.array([dropped.sum() / max(offered.sum(), 1)], np.float32),
+            "mean_delay": np.array([all_delays.mean() if len(all_delays) else np.nan], np.float32),
+            "p99_delay": np.array([np.percentile(all_delays, 99) if len(all_delays) else np.nan], np.float32),
+            "mean_queue": np.array([run.queue.mean()], np.float32),
+            "max_queue": np.array([run.queue.max()], np.int32),
+            "link_utilisation": np.array([run.utilisation], np.float32),
+            "link_saturation": np.array([run.saturation], np.float32),
+            "route_changes": np.array([pf["route_changes"].sum()], np.int32),
+        }, schema=SCHEMAS["router_summary"]))
+        quantiles = np.array([np.percentile(d, [50, 95, 99]) if len(d) else [np.nan] * 3
+                              for d in run.delays], np.float32)
+        parts["flow_summary"].append(pa.table({
+            "episode_id": ep(n_flows), "router": text(router, n_flows),
+            "flow": np.arange(n_flows, dtype=np.int16), "source": flows.source, "sink": flows.sink,
+            "mean_rate": flows.mean_rate, "min_hops": flows.min_hops, "min_latency": flows.min_latency,
+            "offered": offered, "delivered": delivered, "dropped": dropped, "in_flight": run.in_flight,
+            "loss_ratio": (dropped / np.maximum(offered, 1)).astype(np.float32),
+            "mean_delay": _stat(run.delays, np.mean), "delay_std": _stat(run.delays, np.std),
+            "p50_delay": quantiles[:, 0], "p95_delay": quantiles[:, 1], "p99_delay": quantiles[:, 2],
+            "max_delay": _stat(run.delays, np.max, -1, np.int32),
+            "mean_queueing_delay": np.array([(d - p).mean() if len(d) else np.nan
+                                             for d, p in zip(run.delays, run.propagation)], np.float32),
+            "mean_path_latency": _stat(run.propagation, np.mean),
+            "mean_hops": _stat(run.hops, np.mean),
+            "route_changes": pf["route_changes"].sum(0).astype(np.int32),
+        }, schema=SCHEMAS["flow_summary"]))
+        tf = slice(0, tracked)
+        parts["flow_telemetry"].append(pa.table({
+            "episode_id": ep(steps * tracked), "router": text(router, steps * tracked),
+            "step": np.repeat(step, tracked), "flow": np.tile(np.arange(tracked, dtype=np.int16), steps),
+            "mmpp_state": mmpp_state[tf].T.ravel(), "offered": arrivals[tf].T.ravel(),
+            "admitted": pf["admitted"][:, tf].ravel(), "delivered": pf["delivered"][:, tf].ravel(),
+            "dropped": pf["dropped"][:, tf].ravel(), "queued": pf["queued"][:, tf].ravel(),
+            "in_transit": pf["in_transit"][:, tf].ravel(), "mean_delay": flow_mean_delay[:, tf].ravel(),
+            "route_changes": pf["route_changes"][:, tf].ravel(),
+        }, schema=SCHEMAS["flow_telemetry"]))
+        parts["network_telemetry"].append(pa.table({
+            "episode_id": ep(steps), "router": text(router, steps), "step": step,
+            "offered": arrivals.sum(0).astype(np.int32), "admitted": pf["admitted"].sum(1),
+            "delivered": pf["delivered"].sum(1), "dropped": pf["dropped"].sum(1),
+            "queued": pf["queued"].sum(1), "in_transit": pf["in_transit"].sum(1),
+            "mean_delay": step_mean_delay, "route_changes": pf["route_changes"].sum(1),
+            "queue_depth": list_column(run.queue, pa.int16()),
+            "node_dropped": list_column(run.node_drops, pa.int16()),
+        }, schema=SCHEMAS["network_telemetry"]))
+        parts["link_telemetry"].append(pa.table({
+            "episode_id": ep(steps), "router": text(router, steps), "step": step,
+            "load_uv": list_column(run.link_load[:, :n_edges], pa.int16()),
+            "load_vu": list_column(run.link_load[:, n_edges:], pa.int16()),
+        }, schema=SCHEMAS["link_telemetry"]))
+        if run.potential is not None:
+            snapshots = run.potential.shape[0]
+            tables["potential_field"] = pa.table({
+                "episode_id": ep(snapshots), "step": (np.arange(snapshots) * stride).astype(np.int32),
+                "potential": list_column(run.potential.reshape(snapshots, -1), pa.float32()),
+            }, schema=SCHEMAS["potential_field"])
+    for name, chunks in parts.items():
+        tables[name] = pa.concat_tables(chunks)
+    return tables
+
+
+def run_sweep(cfg: SimConfig, data_dir: Path, workers: int, log=print) -> None:
+    """Map every unfinished shard of episodes across `workers` processes and stream it to Parquet."""
+    n_shards = -(-cfg.episodes // cfg.shard_episodes)
+
+    def shard_ids(shard: int) -> range:
+        return range(shard * cfg.shard_episodes, min((shard + 1) * cfg.shard_episodes, cfg.episodes))
+
+    done = completed_shards(data_dir, n_shards, cfg.routers)
+    todo = [s for s in range(n_shards) if s not in done]
+    if done:
+        log(f"Resuming: {len(done)}/{n_shards} shards already complete.")
+    if not todo:
+        log("Nothing to do: every shard is complete.")
+        return
+    episodes_todo = [e for s in todo for e in shard_ids(s)]
+    log(f"Simulating {len(episodes_todo)} episodes x {len(cfg.routers)} routers "
+        f"({len(cfg.cells)} design cells) on {workers} workers ...")
+    start, finished = time.time(), 0
+    with mp.get_context("spawn").Pool(workers) as pool:  # same start method on every platform
+        results = pool.imap(partial(simulate_episode, cfg), episodes_todo, chunksize=1)
+        for shard in todo:
+            ids = shard_ids(shard)
+            write_shard(data_dir, shard, [next(results) for _ in ids])
+            finished += len(ids)
+            elapsed = time.time() - start
+            eta = elapsed / finished * (len(episodes_todo) - finished)
+            log(f"  shard {shard + 1:>4}/{n_shards}  episodes {finished:>6}/{len(episodes_todo)}  "
+                f"elapsed {elapsed / 3600:5.2f} h  eta {eta / 3600:5.2f} h")
+    log(f"Done in {(time.time() - start) / 3600:.2f} h.")

src/telemetry_logger.py

@@ -0,0 +1,164 @@
+"""Streaming Parquet serialisation and the dataset manifest.
+
+The dataset is a relational schema of eight tables. Each shard of episodes is written as one
+``data/<table>/part-XXXXX.parquet`` file (zstd, modest row groups so readers can stream), through
+a temporary file that is renamed only once complete. A shard is therefore either fully present or
+absent, which makes an interrupted sweep resumable and keeps memory bounded to one shard.
+"""
+from __future__ import annotations
+
+import json
+import platform
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, List, Sequence
+
+import numpy as np
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+ROW_GROUP_SIZE = 8192
+
+SCHEMAS: Dict[str, pa.Schema] = {
+    # One row per episode: design cell, split, static graph, flows and traffic parameters.
+    "episodes": pa.schema([
+        ("episode_id", pa.int32()), ("cell_id", pa.int16()), ("replicate", pa.int16()), ("split", pa.string()),
+        ("topology", pa.string()), ("size", pa.int16()), ("traffic_profile", pa.string()),
+        ("load_level", pa.string()), ("dynamics_level", pa.string()),
+        ("n_nodes", pa.int16()), ("n_edges", pa.int32()), ("n_flows", pa.int16()), ("tracked_flows", pa.int16()),
+        ("steps", pa.int32()), ("field_stride", pa.int16()),
+        ("offered_load", pa.float32()), ("total_capacity", pa.float32()),
+        ("edge_u", pa.list_(pa.int16())), ("edge_v", pa.list_(pa.int16())),
+        ("capacity", pa.list_(pa.int16())), ("latency", pa.list_(pa.int16())),
+        ("node_role", pa.list_(pa.int8())), ("node_x", pa.list_(pa.float32())), ("node_y", pa.list_(pa.float32())),
+        ("flow_source", pa.list_(pa.int16())), ("flow_sink", pa.list_(pa.int16())),
+        ("flow_mean_rate", pa.list_(pa.float32())), ("flow_idle_rate", pa.list_(pa.float32())),
+        ("flow_burst_rate", pa.list_(pa.float32())),
+        ("p_idle_to_burst", pa.float32()), ("p_burst_to_idle", pa.float32()),
+    ]),
+    # One row per topology event; active for start <= step < end.
+    "events": pa.schema([
+        ("episode_id", pa.int32()), ("kind", pa.string()), ("start", pa.int32()), ("end", pa.int32()),
+        ("node", pa.int16()), ("edge_u", pa.int16()), ("edge_v", pa.int16()), ("factor", pa.float32()),
+    ]),
+    # One row per (episode, router): network-level benchmark figures.
+    "router_summary": pa.schema([
+        ("episode_id", pa.int32()), ("router", pa.string()),
+        ("offered", pa.int32()), ("delivered", pa.int32()), ("dropped", pa.int32()), ("in_flight", pa.int32()),
+        ("loss_ratio", pa.float32()), ("mean_delay", pa.float32()), ("p99_delay", pa.float32()),
+        ("mean_queue", pa.float32()), ("max_queue", pa.int32()),
+        ("link_utilisation", pa.float32()), ("link_saturation", pa.float32()),
+        ("route_changes", pa.int32()),
+    ]),
+    # One row per (episode, router, flow): end-to-end benchmark figures.
+    "flow_summary": pa.schema([
+        ("episode_id", pa.int32()), ("router", pa.string()), ("flow", pa.int16()),
+        ("source", pa.int16()), ("sink", pa.int16()), ("mean_rate", pa.float32()),
+        ("min_hops", pa.int16()), ("min_latency", pa.int16()),
+        ("offered", pa.int32()), ("delivered", pa.int32()), ("dropped", pa.int32()), ("in_flight", pa.int32()),
+        ("loss_ratio", pa.float32()), ("mean_delay", pa.float32()), ("delay_std", pa.float32()),
+        ("p50_delay", pa.float32()), ("p95_delay", pa.float32()), ("p99_delay", pa.float32()),
+        ("max_delay", pa.int32()), ("mean_queueing_delay", pa.float32()), ("mean_path_latency", pa.float32()),
+        ("mean_hops", pa.float32()), ("route_changes", pa.int32()),
+    ]),
+    # One row per (episode, router, step, tracked flow).
+    "flow_telemetry": pa.schema([
+        ("episode_id", pa.int32()), ("router", pa.string()), ("step", pa.int32()), ("flow", pa.int16()),
+        ("mmpp_state", pa.int8()), ("offered", pa.int32()), ("admitted", pa.int32()),
+        ("delivered", pa.int32()), ("dropped", pa.int32()), ("queued", pa.int32()), ("in_transit", pa.int32()),
+        ("mean_delay", pa.float32()), ("route_changes", pa.int32()),
+    ]),
+    # One row per (episode, router, step): network totals plus occupancy and drops of every node.
+    "network_telemetry": pa.schema([
+        ("episode_id", pa.int32()), ("router", pa.string()), ("step", pa.int32()),
+        ("offered", pa.int32()), ("admitted", pa.int32()), ("delivered", pa.int32()), ("dropped", pa.int32()),
+        ("queued", pa.int32()), ("in_transit", pa.int32()), ("mean_delay", pa.float32()), ("route_changes", pa.int32()),
+        ("queue_depth", pa.list_(pa.int16())), ("node_dropped", pa.list_(pa.int16())),
+    ]),
+    # One row per (episode, router, step): packets forwarded over every link, per direction.
+    "link_telemetry": pa.schema([
+        ("episode_id", pa.int32()), ("router", pa.string()), ("step", pa.int32()),
+        ("load_uv", pa.list_(pa.int16())), ("load_vu", pa.list_(pa.int16())),
+    ]),
+    # One row per logged step of the potential router: φ of the tracked flows, flattened (tracked × N).
+    "potential_field": pa.schema([
+        ("episode_id", pa.int32()), ("step", pa.int32()), ("potential", pa.list_(pa.float32())),
+    ]),
+}
+
+
+def table_names(routers: Sequence[str]) -> List[str]:
+    return [t for t in SCHEMAS if t != "potential_field" or "potential" in routers]
+
+
+def list_column(matrix: np.ndarray, value_type: pa.DataType) -> pa.ListArray:
+    """A (rows, width) array as a list<value_type> column with one fixed-width list per row."""
+    rows, width = matrix.shape
+    offsets = np.arange(0, (rows + 1) * width, width, dtype=np.int32)
+    return pa.ListArray.from_arrays(pa.array(offsets), pa.array(np.ascontiguousarray(matrix).ravel(), type=value_type))
+
+
+def shard_path(data_dir: Path, table: str, shard: int) -> Path:
+    return data_dir / table / f"part-{shard:05d}.parquet"
+
+
+def shard_files(data_dir: Path, table: str) -> List[Path]:
+    return sorted((data_dir / table).glob("part-*.parquet"))
+
+
+def completed_shards(data_dir: Path, n_shards: int, routers: Sequence[str]) -> List[int]:
+    for stale in data_dir.glob("*/*.tmp"):
+        stale.unlink()
+    return [s for s in range(n_shards)
+            if all(shard_path(data_dir, t, s).exists() for t in table_names(routers))]
+
+
+def write_shard(data_dir: Path, shard: int, episodes: List[Dict[str, pa.Table]]) -> None:
+    for table in episodes[0]:
+        final = shard_path(data_dir, table, shard)
+        final.parent.mkdir(parents=True, exist_ok=True)
+        tmp = final.with_name(final.name + ".tmp")
+        pq.write_table(pa.concat_tables([e[table] for e in episodes]), tmp,
+                       compression="zstd", row_group_size=ROW_GROUP_SIZE)
+        tmp.replace(final)
+
+
+def read_table(data_dir: Path, table: str, columns=None, filters=None) -> pa.Table:
+    return pq.read_table(shard_files(data_dir, table), columns=columns, filters=filters)
+
+
+def table_stats(data_dir: Path, table: str) -> Dict[str, int]:
+    files = shard_files(data_dir, table)
+    return {"files": len(files),
+            "rows": sum(pq.read_metadata(f).num_rows for f in files),
+            "bytes": sum(f.stat().st_size for f in files)}
+
+
+def write_manifest(data_dir: Path, cfg, dataset_version: str) -> Dict:
+    """Provenance, design coverage and table statistics of the shards present in `data_dir`."""
+    import networkx, pandas, scipy  # noqa: E401  (versions only)
+
+    episodes = read_table(data_dir, "episodes",
+                          columns=["episode_id", "cell_id", "split", "topology", "size",
+                                   "traffic_profile", "load_level", "dynamics_level"]).to_pandas()
+    coverage = {name: episodes[name].value_counts().sort_index().to_dict()
+                for name in ("topology", "size", "traffic_profile", "load_level", "dynamics_level", "split")}
+    per_cell = episodes.cell_id.value_counts()
+    manifest = {
+        "dataset_version": dataset_version,
+        "created_utc": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        "provenance": {
+            "python": sys.version.split()[0], "platform": platform.platform(),
+            "numpy": np.__version__, "scipy": scipy.__version__, "pyarrow": pa.__version__,
+            "pandas": pandas.__version__, "networkx": networkx.__version__,
+        },
+        "config": json.loads(cfg.to_json()),
+        "design": {"cells": len(cfg.cells), "episodes_planned": cfg.episodes,
+                   "episodes_present": int(len(episodes)),
+                   "episodes_per_cell_min": int(per_cell.min()), "episodes_per_cell_max": int(per_cell.max())},
+        "coverage": {k: {str(kk): int(vv) for kk, vv in v.items()} for k, v in coverage.items()},
+        "tables": {name: table_stats(data_dir, name) for name in table_names(cfg.routers)},
+    }
+    (data_dir / "manifest.json").write_text(json.dumps(manifest, indent=2), encoding="utf-8")
+    return manifest

terminal_logs.txt

@@ -0,0 +1,208 @@
+PS C:\Users\g28630518\Documents\SemanticPotentialRoutingTelemetryDataset> python .\scripts\run_local_sweep.py --smoke
+Smoke test in C:\Users\G28630~1\AppData\Local\Temp\sprt-smoke-scvkh98l
+Simulating 15 episodes x 6 routers (15 design cells) on 12 workers ...
+  shard    1/3  episodes      5/15  elapsed  0.00 h  eta  0.00 h
+  shard    2/3  episodes     10/15  elapsed  0.00 h  eta  0.00 h
+  shard    3/3  episodes     15/15  elapsed  0.00 h  eta  0.00 h
+Done in 0.00 h.
+
+Router benchmark (means over episodes):
+                        loss_ratio  mean_delay  p99_delay  link_utilisation  route_changes
+router
+adaptive_shortest_path       0.037       9.524  24.333000             0.117      39109.533
+ecmp                         0.263      11.356  50.390999             0.094         72.600
+potential                    0.074      10.387  28.132999             0.112      18638.000
+potential_split              0.024      11.443  29.933001             0.131      10474.333
+potential_static             0.179      11.519  33.266998             0.118        330.467
+shortest_path                0.264      11.205  42.466999             0.093         72.600
+
+Design coverage (episodes per level):
+  topology         barabasi_albert=3  erdos_renyi=3  fat_tree=3  watts_strogatz=3  waxman=3
+  size             32=15
+  traffic_profile  microburst=5  poisson=5  sustained=5
+  load_level       heavy=15
+  dynamics_level   severe=15
+  split            train=15
+  cells 15, episodes 15/15, per cell 1-1
+
+Tables:
+  episodes               3 files             15 rows     0.00 GB
+  events                 3 files             65 rows     0.00 GB
+  router_summary         3 files             90 rows     0.00 GB
+  flow_summary           3 files          5,184 rows     0.00 GB
+  flow_telemetry         3 files        144,000 rows     0.00 GB
+  network_telemetry      3 files         18,000 rows     0.00 GB
+  link_telemetry         3 files         18,000 rows     0.00 GB
+  potential_field        3 files          3,000 rows     0.00 GB
+  total                                                  0.01 GB
+
+Smoke test passed.
+PS C:\Users\g28630518\Documents\SemanticPotentialRoutingTelemetryDataset> python .\scripts\run_local_sweep.py
+Simulating 5400 episodes x 6 routers (540 design cells) on 12 workers ...
+  shard    1/135  episodes     40/5400  elapsed  0.01 h  eta  1.56 h
+  shard    2/135  episodes     80/5400  elapsed  0.06 h  eta  4.22 h
+  shard    3/135  episodes    120/5400  elapsed  0.27 h  eta 11.80 h
+  shard    4/135  episodes    160/5400  elapsed  0.27 h  eta  8.92 h
+  shard    5/135  episodes    200/5400  elapsed  0.37 h  eta  9.60 h
+  shard    6/135  episodes    240/5400  elapsed  0.49 h  eta 10.58 h
+  shard    7/135  episodes    280/5400  elapsed  0.50 h  eta  9.10 h
+  shard    8/135  episodes    320/5400  elapsed  0.69 h  eta 10.94 h
+  shard    9/135  episodes    360/5400  elapsed  0.76 h  eta 10.66 h
+  shard   10/135  episodes    400/5400  elapsed  0.78 h  eta  9.79 h
+  shard   11/135  episodes    440/5400  elapsed  1.07 h  eta 12.04 h
+  shard   12/135  episodes    480/5400  elapsed  1.07 h  eta 11.00 h
+  shard   13/135  episodes    520/5400  elapsed  1.17 h  eta 10.98 h
+  shard   14/135  episodes    560/5400  elapsed  1.34 h  eta 11.58 h
+  shard   15/135  episodes    600/5400  elapsed  1.35 h  eta 10.77 h
+  shard   16/135  episodes    640/5400  elapsed  1.58 h  eta 11.74 h
+  shard   17/135  episodes    680/5400  elapsed  1.66 h  eta 11.50 h
+  shard   18/135  episodes    720/5400  elapsed  1.68 h  eta 10.93 h
+  shard   19/135  episodes    760/5400  elapsed  1.97 h  eta 12.05 h
+  shard   20/135  episodes    800/5400  elapsed  1.98 h  eta 11.38 h
+  shard   21/135  episodes    840/5400  elapsed  2.09 h  eta 11.34 h
+  shard   22/135  episodes    880/5400  elapsed  2.31 h  eta 11.87 h
+  shard   23/135  episodes    920/5400  elapsed  2.32 h  eta 11.28 h
+  shard   24/135  episodes    960/5400  elapsed  2.50 h  eta 11.59 h
+  shard   25/135  episodes   1000/5400  elapsed  2.60 h  eta 11.45 h
+  shard   26/135  episodes   1040/5400  elapsed  2.61 h  eta 10.94 h
+  shard   27/135  episodes   1080/5400  elapsed  2.88 h  eta 11.52 h
+  shard   28/135  episodes   1120/5400  elapsed  2.88 h  eta 11.02 h
+  shard   29/135  episodes   1160/5400  elapsed  2.92 h  eta 10.69 h
+  shard   30/135  episodes   1200/5400  elapsed  3.23 h  eta 11.31 h
+  shard   31/135  episodes   1240/5400  elapsed  3.24 h  eta 10.87 h
+  shard   32/135  episodes   1280/5400  elapsed  3.38 h  eta 10.90 h
+  shard   33/135  episodes   1320/5400  elapsed  3.58 h  eta 11.05 h
+  shard   34/135  episodes   1360/5400  elapsed  3.58 h  eta 10.64 h
+  shard   35/135  episodes   1400/5400  elapsed  3.83 h  eta 10.95 h
+  shard   36/135  episodes   1440/5400  elapsed  3.91 h  eta 10.76 h
+  shard   37/135  episodes   1480/5400  elapsed  3.95 h  eta 10.45 h
+  shard   38/135  episodes   1520/5400  elapsed  4.26 h  eta 10.88 h
+  shard   39/135  episodes   1560/5400  elapsed  4.27 h  eta 10.50 h
+  shard   40/135  episodes   1600/5400  elapsed  4.38 h  eta 10.39 h
+  shard   41/135  episodes   1640/5400  elapsed  4.56 h  eta 10.46 h
+  shard   42/135  episodes   1680/5400  elapsed  4.57 h  eta 10.12 h
+  shard   43/135  episodes   1720/5400  elapsed  4.82 h  eta 10.32 h
+  shard   44/135  episodes   1760/5400  elapsed  4.89 h  eta 10.12 h
+  shard   45/135  episodes   1800/5400  elapsed  4.92 h  eta  9.84 h
+  shard   46/135  episodes   1840/5400  elapsed  5.18 h  eta 10.03 h
+  shard   47/135  episodes   1880/5400  elapsed  5.19 h  eta  9.71 h
+  shard   48/135  episodes   1920/5400  elapsed  5.28 h  eta  9.57 h
+  shard   49/135  episodes   1960/5400  elapsed  5.47 h  eta  9.60 h
+  shard   50/135  episodes   2000/5400  elapsed  5.47 h  eta  9.31 h
+  shard   51/135  episodes   2040/5400  elapsed  5.65 h  eta  9.31 h
+  shard   52/135  episodes   2080/5400  elapsed  5.74 h  eta  9.16 h
+  shard   53/135  episodes   2120/5400  elapsed  5.75 h  eta  8.89 h
+  shard   54/135  episodes   2160/5400  elapsed  6.00 h  eta  9.00 h
+  shard   55/135  episodes   2200/5400  elapsed  6.00 h  eta  8.73 h
+  shard   56/135  episodes   2240/5400  elapsed  6.03 h  eta  8.51 h
+  shard   57/135  episodes   2280/5400  elapsed  6.29 h  eta  8.61 h
+  shard   58/135  episodes   2320/5400  elapsed  6.30 h  eta  8.36 h
+  shard   59/135  episodes   2360/5400  elapsed  6.42 h  eta  8.27 h
+  shard   60/135  episodes   2400/5400  elapsed  6.58 h  eta  8.22 h
+  shard   61/135  episodes   2440/5400  elapsed  6.58 h  eta  7.98 h
+  shard   62/135  episodes   2480/5400  elapsed  6.79 h  eta  8.00 h
+  shard   63/135  episodes   2520/5400  elapsed  6.87 h  eta  7.86 h
+  shard   64/135  episodes   2560/5400  elapsed  6.89 h  eta  7.65 h
+  shard   65/135  episodes   2600/5400  elapsed  7.20 h  eta  7.75 h
+  shard   66/135  episodes   2640/5400  elapsed  7.20 h  eta  7.53 h
+  shard   67/135  episodes   2680/5400  elapsed  7.30 h  eta  7.41 h
+  shard   68/135  episodes   2720/5400  elapsed  7.47 h  eta  7.36 h
+  shard   69/135  episodes   2760/5400  elapsed  7.48 h  eta  7.15 h
+  shard   70/135  episodes   2800/5400  elapsed  7.72 h  eta  7.17 h
+  shard   71/135  episodes   2840/5400  elapsed  7.80 h  eta  7.03 h
+  shard   72/135  episodes   2880/5400  elapsed  7.83 h  eta  6.85 h
+  shard   73/135  episodes   2920/5400  elapsed  8.14 h  eta  6.91 h
+  shard   74/135  episodes   2960/5400  elapsed  8.14 h  eta  6.71 h
+  shard   75/135  episodes   3000/5400  elapsed  8.25 h  eta  6.60 h
+  shard   76/135  episodes   3040/5400  elapsed  8.48 h  eta  6.59 h
+  shard   77/135  episodes   3080/5400  elapsed  8.49 h  eta  6.39 h
+  shard   78/135  episodes   3120/5400  elapsed  8.74 h  eta  6.39 h
+  shard   79/135  episodes   3160/5400  elapsed  8.84 h  eta  6.27 h
+  shard   80/135  episodes   3200/5400  elapsed  8.85 h  eta  6.09 h
+  shard   81/135  episodes   3240/5400  elapsed  9.14 h  eta  6.09 h
+  shard   82/135  episodes   3280/5400  elapsed  9.14 h  eta  5.91 h
+  shard   83/135  episodes   3320/5400  elapsed  9.18 h  eta  5.75 h
+  shard   84/135  episodes   3360/5400  elapsed  9.47 h  eta  5.75 h
+  shard   85/135  episodes   3400/5400  elapsed  9.48 h  eta  5.57 h
+  shard   86/135  episodes   3440/5400  elapsed  9.61 h  eta  5.48 h
+  shard   87/135  episodes   3480/5400  elapsed  9.78 h  eta  5.40 h
+  shard   88/135  episodes   3520/5400  elapsed  9.79 h  eta  5.23 h
+  shard   89/135  episodes   3560/5400  elapsed 10.03 h  eta  5.18 h
+  shard   90/135  episodes   3600/5400  elapsed 10.10 h  eta  5.05 h
+  shard   91/135  episodes   3640/5400  elapsed 10.13 h  eta  4.90 h
+  shard   92/135  episodes   3680/5400  elapsed 10.42 h  eta  4.87 h
+  shard   93/135  episodes   3720/5400  elapsed 10.43 h  eta  4.71 h
+  shard   94/135  episodes   3760/5400  elapsed 10.55 h  eta  4.60 h
+  shard   95/135  episodes   3800/5400  elapsed 10.78 h  eta  4.54 h
+  shard   96/135  episodes   3840/5400  elapsed 10.79 h  eta  4.38 h
+  shard   97/135  episodes   3880/5400  elapsed 11.03 h  eta  4.32 h
+  shard   98/135  episodes   3920/5400  elapsed 11.12 h  eta  4.20 h
+  shard   99/135  episodes   3960/5400  elapsed 11.14 h  eta  4.05 h
+  shard  100/135  episodes   4000/5400  elapsed 11.44 h  eta  4.00 h
+  shard  101/135  episodes   4040/5400  elapsed 11.44 h  eta  3.85 h
+  shard  102/135  episodes   4080/5400  elapsed 11.55 h  eta  3.74 h
+  shard  103/135  episodes   4120/5400  elapsed 11.75 h  eta  3.65 h
+  shard  104/135  episodes   4160/5400  elapsed 11.76 h  eta  3.51 h
+  shard  105/135  episodes   4200/5400  elapsed 11.96 h  eta  3.42 h
+  shard  106/135  episodes   4240/5400  elapsed 12.06 h  eta  3.30 h
+  shard  107/135  episodes   4280/5400  elapsed 12.07 h  eta  3.16 h
+  shard  108/135  episodes   4320/5400  elapsed 12.35 h  eta  3.09 h
+  shard  109/135  episodes   4360/5400  elapsed 12.36 h  eta  2.95 h
+  shard  110/135  episodes   4400/5400  elapsed 12.39 h  eta  2.82 h
+  shard  111/135  episodes   4440/5400  elapsed 12.67 h  eta  2.74 h
+  shard  112/135  episodes   4480/5400  elapsed 12.68 h  eta  2.60 h
+  shard  113/135  episodes   4520/5400  elapsed 12.81 h  eta  2.49 h
+  shard  114/135  episodes   4560/5400  elapsed 12.97 h  eta  2.39 h
+  shard  115/135  episodes   4600/5400  elapsed 12.98 h  eta  2.26 h
+  shard  116/135  episodes   4640/5400  elapsed 13.21 h  eta  2.16 h
+  shard  117/135  episodes   4680/5400  elapsed 13.29 h  eta  2.04 h
+  shard  118/135  episodes   4720/5400  elapsed 13.31 h  eta  1.92 h
+  shard  119/135  episodes   4760/5400  elapsed 13.58 h  eta  1.83 h
+  shard  120/135  episodes   4800/5400  elapsed 13.59 h  eta  1.70 h
+  shard  121/135  episodes   4840/5400  elapsed 13.68 h  eta  1.58 h
+  shard  122/135  episodes   4880/5400  elapsed 13.83 h  eta  1.47 h
+  shard  123/135  episodes   4920/5400  elapsed 13.83 h  eta  1.35 h
+  shard  124/135  episodes   4960/5400  elapsed 14.05 h  eta  1.25 h
+  shard  125/135  episodes   5000/5400  elapsed 14.12 h  eta  1.13 h
+  shard  126/135  episodes   5040/5400  elapsed 14.14 h  eta  1.01 h
+  shard  127/135  episodes   5080/5400  elapsed 14.41 h  eta  0.91 h
+  shard  128/135  episodes   5120/5400  elapsed 14.41 h  eta  0.79 h
+  shard  129/135  episodes   5160/5400  elapsed 14.50 h  eta  0.67 h
+  shard  130/135  episodes   5200/5400  elapsed 14.69 h  eta  0.56 h
+  shard  131/135  episodes   5240/5400  elapsed 14.69 h  eta  0.45 h
+  shard  132/135  episodes   5280/5400  elapsed 14.87 h  eta  0.34 h
+  shard  133/135  episodes   5320/5400  elapsed 14.96 h  eta  0.22 h
+  shard  134/135  episodes   5360/5400  elapsed 14.97 h  eta  0.11 h
+  shard  135/135  episodes   5400/5400  elapsed 15.16 h  eta  0.00 h
+Done in 15.17 h.
+
+Router benchmark (means over episodes):
+                        loss_ratio  mean_delay  p99_delay  link_utilisation  route_changes
+router
+adaptive_shortest_path       0.016      10.344  20.948000             0.054    5268980.419
+ecmp                         0.118      11.639  34.861000             0.047       1284.729
+potential                    0.034      12.297  27.170000             0.054    5176894.254
+potential_split              0.011      15.048  36.096001             0.062    3228916.197
+potential_static             0.102      14.229  32.320000             0.059      12504.789
+shortest_path                0.161      12.115  36.713001             0.044       1284.729
+
+Design coverage (episodes per level):
+  topology         barabasi_albert=1080  erdos_renyi=1080  fat_tree=1080  watts_strogatz=1080  waxman=1080
+  size             32=1350  64=1350  128=1350  256=1350
+  traffic_profile  microburst=1800  poisson=1800  sustained=1800
+  load_level       heavy=1800  light=1800  moderate=1800
+  dynamics_level   moderate=1800  severe=1800  static=1800
+  split            test=1080  train=3240  validation=1080
+  cells 540, episodes 5400/5400, per cell 10-10
+
+Tables:
+  episodes             135 files          5,400 rows     0.03 GB
+  events               135 files         43,246 rows     0.00 GB
+  router_summary       135 files         32,400 rows     0.00 GB
+  flow_summary         135 files      7,672,320 rows     0.19 GB
+  flow_telemetry       135 files    259,200,000 rows     0.96 GB
+  network_telemetry    135 files     32,400,000 rows     3.69 GB
+  link_telemetry       135 files     32,400,000 rows     9.27 GB
+  potential_field      135 files      1,501,470 rows     3.48 GB
+  total                                                 17.62 GB
+PS C:\Users\g28630518\Documents\SemanticPotentialRoutingTelemetryDataset> python .\scripts\validate_dataset.py