How much of an open-source chip design search can cheap fidelity rungs and proof prediction save, with a guarantee?

2026-10-31 · Milestone 45: does the rank displacement rho/k grow with pool size? (exploratory; no predictions were written before the script ran)

• Why: milestone 44's "Next". experiments/theory/optimum_rank_n.py (no flow run, a few seconds) subsamples each of the 20 cached r1-start cells to n' = 20, 30, 40, 50 candidates (200 subsamples each, the optimum recomputed on the subsample, keeps n'//3, n'//9, n'//27 floored at 1) and takes the worst rho_j/k_j over the three cuts.
• Outcome (optimum_rank_n_results.txt): median rho/k 2.33, 2.60, 3.00, 3.00 and mean 4.2, 5.7, 7.2, 8.9 at n' = 20, 30, 40, 50; the share of subsamples with rho/k <= 1 falls 0.168, 0.130, 0.086, 0.050 and the share <= 2 falls 0.475, 0.474, 0.414, 0.300. So the zero-regret assumption D(1) gets harder as the pool grows, not easier.
• Reading: this is partly built in. The last cut keeps k = 1 at every n' tested, so its ratio is the raw count rho_3, which can only grow with the pool, while the earlier cuts' k grow with n'. The result says the assumption cannot be expected to hold on larger pools; it does not say how fast rho/k grows beyond 50.
• Limits: pools are capped at the 50 to 52 cached candidates, so nothing above n' = 50 is measured; subsamples of one table overlap, so the 200 draws per cell are not independent; no tests (script only); the two clocks and ten designs are 20 cells, not 20 independent designs.
• Next: a pool above 52 candidates needs new flow runs (OpenROAD); until then rho/k at larger n is untested.

2026-10-30 · Milestone 44: how far do the rungs displace the pool optimum, and is a rank assumption on it enough for zero regret? (exploratory; no predictions were written before the script ran)

• Why: milestone 43 said a pilot-side guarantee needs an assumption on the optimum's own excess. The simplest one is rank displacement: x is cut at a cut keeping k only if at least k rivals rank at or ahead of it, so if rho_j (rivals at or ahead of x under cut j's score) is below k_j at every cut, regret is exactly 0 (the kappa = 0 case of milestone 39). experiments/theory/optimum_rank.py (no flow run, about 5 s) measures rho_j / k_j on the 40 cached cells and checks the implication over 200 tie-breaks each.
• Outcome (optimum_rank_results.txt): the implication holds (0 of the 11 guaranteed cells shows any regret). Cells whose worst rho/k is at most 1, 2 and 4: 13, 21 and 29 of 40; median 1.97. Where rho/k > 1, only 0.167 of tie-breaks reach zero regret on average.
• Reading: the assumption "x* ranks inside the survivors at every rung" is a guarantee in 11 of 40 cells and nearly one in three at most; it does not hold generally, and failing it by a factor 2 already loses the zero-regret outcome in most draws. The optimum is typically within about 2 survivor-widths of the cut line, which is why halving sees non-zero regret in the other cells. A usable pilot-side assumption would bound rho/k from above by a constant and then bound the excess among those rivals, which is the quantity milestone 43 showed cannot be got from a quantile.
• Limits: one table and tool version; x* is the pool optimum, so a pilot cannot compute rho (it is not observed without the full table); no tests (script only).
• Next: model rho/k across pool sizes (does it grow with n?) or detail routing, which needs OpenROAD.

2026-10-30 · Milestone 43: no quantile of the per-candidate excess g bounds halving regret in general (a counterexample; theory, no flow run)

• Why: milestones 41 and 42 found the q-quantile of g covers empirically except in cells where the pool optimum itself has a large g. This asks whether any q < 1 can be made to work as a theorem. experiments/theory/quantile_counterexample.py builds the smallest instance: one cut to n/3 survivors, the optimum (y = 1) ranked last by the rung, every other candidate at y = c ranked by index. Every other candidate has only equal-y rivals ahead of it, so g = 0 for all but the optimum, whose g is log c.
• Outcome (quantile_counterexample_results.txt; tests/test_bound.py::test_no_quantile_of_g_bounds_halving_regret, n = 30, 90, 300): the optimum is cut at the first cut, so realised regret is log c (0.693 for c = 2, 2.303 for c = 10), while the 0.5, 0.9 and 0.95 quantiles of g are 0 for every n tried (30 to 3000); the 0.99 quantile is 0 once n >= 100. In general the q-quantile is 0 whenever q <= 1 - 1/n, so for any fixed q < 1 and large n the claim "regret <= sum of the cut quantiles of g" is false.
• Reading: this closes the branch from 41 and 42. The empirical coverage (97.6% of pilot draws at q = 0.95) is a property of this table, where the optimum is rarely an outlier in g; it cannot become a certificate by choosing q or the pilot size, because the failure instance puts all of the regret on one candidate. Only q = 1 (the maximum, milestone 37's bound) is valid, and the pilot cannot certify a maximum (milestones 38 and 40). A pilot-side regret guarantee needs an assumption that bounds the optimum's own excess, not a better statistic.
• Limits: a constructed instance, not a claim that real tables look like it (the real table has 2 failing cells of 40 at q = 0.9); one cut; it shows quantiles cannot be a theorem, not that they are useless as a diagnostic.
• Next: state an assumption on the optimum's excess (for example, bounded rank-displacement of the optimum under the rung) that a pilot can check, or detail routing, which needs OpenROAD.

2026-10-30 · Milestone 42: does a quantile of g computed inside a 16-point pilot bound halving regret? (exploratory; no predictions were written before the script ran)

• Why: milestone 41 left a pilot-side version open. experiments/theory/quantile_g_pilot.py (no flow run, about 1 minute) draws 300 random 16-point pilots per cell, computes g^(k') on the pilot alone (rivals inside the pilot, k' = max(1, round(k x 16 / n))), takes the q-quantile over pilot candidates, sums over cuts, and compares with the realised full-pool regret of optimum-seeking halving (40 cells x 200 tie-breaks).
• Outcome (quantile_g_pilot_results.txt): share of (pilot, tie-break) draws with regret above the pilot bound: q = 0.5 0.523, q = 0.9 0.0762, q = 0.95 0.0242. Cells where more than 20% of draws violate: 23, 5 and 1 of 40. The pilot bound is under the spread of y in over half the pilots in 40, 37 and 36 cells. Median pilot / full-table bound: 0.01, 1.05, 1.02.
• Reading: at q = 0.95 a 16-point pilot gives a bound that holds in 97.6% of draws and says something (is under the spread) in 36 of 40 cells, using no full table; at q = 0.9 the violation share is 7.6%, above 5%. This is empirical coverage on one table, not a certificate: the same 1 cell fails as in milestone 41, and the pilot quantile is not proved to dominate the optimum's g.
• Limits: one table and tool version; pilot size, q grid and k scaling fixed once; the pilot is iid from the pool (pool-wide, not the 8 disjoint pairs of milestone 36); no tests (script only).
• Next: a proof or a counter-example for the quantile bound, or detail routing, which needs OpenROAD.

2026-10-30 · Milestone 41: does a quantile of the per-candidate excess g_x^(k) bound halving regret? (predictions fixed before the script ran)

• Why: milestone 40 showed no fixed multiplier turns a 16-point pilot estimate of iota^(k) (a maximum over candidates) into a bound. The extreme-value alternative: replace the maximum by the q-quantile Q_q of g_x^(k) over candidates x (g_x^(k) = k-th largest of max(0, log y(z) - log y(x)) over rivals z ranked at or ahead of x). A pilot of m iid candidates sees a value at or above Q_q with probability 1 - q^m (0.81 for q = 0.9, m = 16), so a quantile is the thing a pilot could certify. experiments/theory/quantile_g.py (no flow run) uses the full table to ask whether sum_j Q_q(g^(k_j)) bounds the realised regret of the optimum-seeking halving, over the 40 group x start cells and 200 tie-breaks, for q in {0.5, 0.75, 0.9, 0.95}.
• Predictions (fixed now): (1) At q = 0.9 realised regret exceeds the quantile bound in more than 5% of (cell, tie-break) draws, because the pool optimum is selected, not sampled (the winner's curse of milestone 4 again), so a quantile of g over all candidates under-describes g at x*. (2) The share of cells with a violation falls with q but is still above 0 at q = 0.95. (3) The q = 0.9 bound is under the spread of y in more cells than the max bound (32). Each is refuted by the opposite.
• Limits known up front: idealised (rivals come from the full table, not from the pilot); one table and tool version; a quantile bound is probabilistic at best and is not a theorem about the argmin.

### Outcome (experiments/theory/quantile_g.py, about 3 s, quantile_g_results.txt; 40 cells x 200 tie-breaks)

• Share of draws with realised regret above the quantile bound: q = 0.5 0.511, 0.75 0.286, 0.9 0.0500, 0.95 0.0250. Cells with any violation: 21, 12, 2, 1 of 40. The q = 0.9 bound is under the spread of y in 38 cells (the max bound: 32).
• (1) refuted, narrowly: the violation share at q = 0.9 is 0.0500 exactly (400 of 8000), not above 5%. (2) held: one cell still fails at q = 0.95. (3) held: 38 against 32 non-vacuous cells.
• Reading: the quantile bound is much tighter than the maximum and almost always holds, but its failures are whole cells, not unlucky draws: the two violating cells (tight adder_op16 starting at R2, relaxed mac4 starting at R1) fail on all 200 tie-breaks, because in them the pool optimum is itself one of the few candidates with a large g, so a quantile over all candidates misses it. That is the winner's-curse mechanism predicted, but it bites in 2 to 3 cells of 40, not broadly. The 1 - q^m coverage of a pilot maximum is about candidates drawn at random, and the argmin is not one, so this is not a certificate; it is evidence that a pilot-side certificate anchored to the optimum (not to a random candidate) is what is missing.
• Limits: idealised (rivals from the full table, not the pilot); one table and tool version; q chosen on a grid of four; no pilot-side version run; no tests (script only).
• Next: a pilot-side version (g computed from pilot rivals, quantile of the pilot's own g, and the share of cells where it covers), or detail routing, which needs OpenROAD.

2026-10-29 · Milestone 40: can a fixed multiplier turn the 16-point pilot estimate of iota^(k) into a bound? (negative; exploratory, no predictions written before the script ran)

• Why: milestone 38 left the pilot-side regret certificate open, with "an inflation whose validity is not proved". experiments/theory/kth_inflate.py (about 5 s, no flow run) reuses milestone 38's 55 cells and seeded pilots and asks what multiplier c makes c x (pilot estimate) >= the full-table iota^(k) in 80% of draws, and whether one c chosen on other designs transfers to a held-out design.
• Outcome (kth_inflate_results.txt): coverage >= 0.8 in 0 / 6 / 18 / 35 / 44 / 49 of 55 cells for c = 1 / 1.25 / 1.5 / 2 / 3 / 5. Per-cell multiplier for 80%: median 1.75, p90 5.79, and no finite multiplier in 2 cells (pilot value 0 in over 20% of draws). Leave-one-design-out: the multiplier picked on the other nine designs (3 to 5) covers 44 of 55 held-out cells; per design it fails in 3 of 6 cells for adder_op16 and crc16, 2 of 6 for fifo8x4 and mac4, and the single adder_ripple16 cell.
• Reading: a fixed inflation does not give a bound. The factor needed spans 1 to above 5 across cells and the pilot can be exactly 0, so any certificate from this estimator would need a model of how the k-th rival excess grows with pool size, not a constant. The regret bound stays a full-table diagnostic; the paper's claim is unchanged.
• Limits: empirical coverage over 300 pilots per cell on one table and tool version; the grid of multipliers is coarse; no proof either way; no tests (script only).
• Next: the paper's theory section with iota^(k) stated as a full-table diagnostic, or an extreme-value argument for the pilot maximum.

2026-10-29 · Paper sync: section 6 item 4 now cites milestones 36 and 38 (documentation only; no experiment)

• Why: PAPER.md section 6 item 4 still described the milestone 35 state (disjoint pairs unproved) and did not mention the proved independent-pairs pilot (milestone 36, coverage 0.826 or more over 60 cells) or the failed pilot estimate of iota^(k) (milestone 38, median 0.85 of the true value, no coverage statement). Section 4 already carried milestones 37 and 39.
• Outcome: item 4 updated with both, numbers copied from the result files. No new measurement.
• Next: a pilot-side regret certificate is the open theory item; anchoring the later cuts to the best survivor depends on the tie-break and so far looks worth under 15%, so the larger payoff is detail routing (item 1).

2026-10-28 · Milestone 39: an optimum-anchored halving bound (theorem plus check; exploratory, no predictions written before the script ran)

• Why: milestone 37's bound maximises over every candidate x, which is why it stays about 3 times the realised regret. Only the pool optimum x matters for regret. If x survives every cut regret is 0; if its first cut is j, the best survivor of that cut is within kappa^(k_j) (the k_j-th largest excess over x among rivals ranked at or ahead of x; 0 if fewer than k_j rivals, since then x* cannot be cut), and each later cut costs at most iota^(k_l). So regret <= max_j [kappa^(k_j) + sum_{l>j} iota^(k_l)] <= sum_j iota^(k_j), because kappa <= iota. experiments/theory/anchored.py (about 10 s, no flow run) checks it on the 40 cached cells with 200 tie-breaks each; tests/test_bound.py checks validity and the ordering on 400 random two-cut instances.
• Outcome (anchored_results.txt): 0 violations. New bound is below the milestone 37 bound in 23 of 37 cells with a positive old bound (equal in the rest), median new/old 0.89; non-vacuous (under the spread of y) in 33 cells against 32; median bound over the largest realised regret 2.77 against 3.02; 3 cells have bound 0.
• Reading: anchoring at the optimum is valid but buys little (about 11% at the median): the slack is mostly in the later cuts' iota^(k), which still maximise over all candidates. It also still needs the full table. A tighter certificate has to anchor those later cuts too (to the best survivor, which depends on the tie-break), or give up the worst case.
• Limits: one table and tool version; survivor counts n/3, n/9, n/27 only; nothing here is pilot-checkable.
• Next: put the theory (milestones 35 to 39) into the paper's section 4 as stated, or study anchoring the later cuts.

2026-10-28 · Milestone 38: can a 16-point pilot estimate iota^(k)? (negative; no predictions were written before this run, so read it as exploratory)

• Why: milestone 37 left "a pilot-checkable estimator of iota^(k)" open. experiments/theory/kth_pilot.py (about 1 s, no flow run) computes iota^(k) on a random pilot of 16 routed points (k scaled to the pilot's share of the pool, round(k x 16 / n), at least 1) and compares it with the full-table value, over the 55 group-rung cells where the true value is positive, 300 pilots per cell. A pilot value is a lower bound on the true one (a sub-maximum over a subset), so the question is how far below.
• Outcome (kth_pilot_results.txt): median of pilot median / true is 0.85 (min 0.00); no cell has the pilot reaching the true value in 80% of draws; 35 of 55 cells reach half the true value in at least 80% of draws; no cell is hopeless (none stays under half in 90% of draws).
• Reading: the raw pilot estimate is always below the truth and typically within 15% at the median, but it carries no coverage statement; turning it into an upper bound needs an inflation whose validity this run does not prove. The honest status of the bound stays "a diagnostic on a full table"; the pilot-side certificate is still open (the quantile pilot of milestones 35 and 36 bounds the share of bad pairs, not iota^(k)).
• Limits: one table and tool version; pilot size and k scaling chosen once, not tuned; no tests added (script only).
• Next: a coverage argument for an inflated estimator (e.g. a pilot maximum plus a quantile-of-pairs slack), or move on to the paper's theory section with iota^(k) stated as a full-table diagnostic.

2026-10-28 · Milestone 37: a regret bound that improves with the survivor count k (theorem; predictions fixed before the script ran)

• Why: milestones 35 and 36 closed the pilot-coverage item and left the real gap, a bound on halving's regret that uses k_j (BOUND.md: "does not use k_j at all"). New statement (proof in experiments/theory/KTH.md): define iota^(k) = max over x of the k-th largest of max(0, log y(z) - log y(x)) over rivals z ranked at or ahead of x. A cut that keeps k points loses at most iota^(k), because x is cut only if all k survivors are rivals of x, and the best of any k rivals is at most the k-th largest. So regret <= sum_j iota^(k_j); iota^(1) is the old iota, and iota^(k) is non-increasing in k. experiments/theory/kth.py (no flow run) evaluates it on the cached rung_bias table with the milestone 6 survivor counts (n/3, n/9, n/27) and 200 random tie-breaks per cell, and checks the bound against realised regret.
• Predictions (fixed now): (1) The bound is never violated (it is a proof; any violation is a bug in the statement or the code). (2) The new bound is below the old one in at least 80% of group-rung cells, with median ratio (new / old) under 0.5. (3) The new bound still dominates the realised regret and is non-vacuous (under the spread log(max y / min y)) in more cells than the old bound. Each is refuted by the opposite.
• Limits known in advance: it is still a worst case over x (the maximum over all candidates, not only the optimum), so it can stay loose; it needs the pool-wide table, so it is a diagnostic on cached tables, not a pilot-checkable certificate (a pilot estimate of iota^(k) is the next step).

### Outcome (experiments/theory/kth.py about 10 s, kth_results.txt; no flow run)

• (1) held. 0 violations over 40 cells x 200 tie-breaks; tests/test_bound.py also checks the bound on 400 random two-cut instances and that iota^(1) = iota and iota^(k) is non-increasing in k.
• (2) half held. New below old in 39 of the 39 cells where the old bound is positive, but the median ratio is 0.543 (range 0.000 to 0.820), not under 0.5.
• (3) held. Non-vacuous (under the spread of y) in 32 of 40 cells against 16 for the old bound. Median bound over the largest realised regret falls from 5.45 to 3.02, so it is still loose by about a factor of 3.
• Reading: using k_j removes about 46% of the bound at the median and doubles the number of cells where it says something, with a proof. It is still a worst case over candidates and needs the full table.
• Limits: one table and tool version, the milestone 6 survivor counts (n/3, n/9, n/27) only; the bound is a maximum over all candidates; no pilot estimator yet.
• Next: a pilot-checkable estimator of iota^(k) (rivals of the pilot's best points) with a coverage argument, then the paper's theory section.

2026-10-28 · Milestone 36: coverage of the with-replacement (independent-pairs) pilot quantile on the cached tables (predictions fixed before the script ran)

• Why: milestone 35 showed the disjoint scheme is not proved and that the independent-pairs scheme (each pair a uniform pair of distinct pool points, points may repeat) is, with P(F(q) > alpha) <= (1 - alpha)^n. Its coverage was never measured. experiments/theory/with_replacement.py (no flow run) repeats quantile.py's 2000-pilot design on the same 60 group-rung cells (alpha = delta = 0.2, n = 8 pairs) with independent pairs, and tabulates coverage, the median q, and the realised point cost.
• Predictions (fixed now): (1) Every cell's coverage is at least 0.8 minus the 95% binomial margin (0.765), as the proof says; the minimum is 0.80 to 0.87. (2) Median q is within 0.02 of the disjoint scheme's median q in at least 80% of cells (repeats matter little at N of 100 or more). (3) Mean distinct points per pilot is at least 15.8 of 16. Each is refuted by the opposite.
• Limits known in advance: coverage is the share of 2000 pilots, so cells carry a binomial margin of about 0.018; same tables as milestone 7a.

### Outcome (experiments/theory/with_replacement.py about 12 s, with_replacement_results.txt; no flow run)

• (1) held. Coverage over the 60 cells: min 0.826, median 0.864, none under 0.8 (the binomial floor is 0.782: my "0.765" above mis-stated it; the script computes 0.782). The proved scheme covers at least as well as the disjoint one (min 0.835 in milestone 7a), and the proof says it must.
• (2) held. The median q is within 0.02 of the disjoint scheme's in 60 of 60 cells.
• (3) refuted, because my premise was wrong. The pools have 50 or 52 points, not 100 or more; a pilot has 13.94 distinct points of 16 on average (min over cells 13.86), as expected for 16 draws from 50. So the cost bound (at most 2n = 16 routed points) holds and is slightly loose; the cost is lower than disjoint, the coverage no worse.
• Reading: the paper can state the independent-pairs pilot with its proof and an empirical coverage of 0.83 or more, at a cost of about 14 routed points rather than 16. This closes the pilot-coverage item; the regret-side theorem is still open.
• Limits: 2000 pilots per cell; the same 12 clock-design groups; pools of 50, so the repeat rate is high and would fall at larger N.
• Next: the regret-side theorem (pairs involving the optimum).

2026-10-28 · Milestone 35: is the disjoint-pair pilot quantile (QUANTILE.md) actually proved? (hypothesis fixed before the script ran; theory item 4 of the paper's list)

• Why: QUANTILE.md proves P(F(q) > alpha) <= (1 - alpha)^n for independent pairs and says the disjoint scheme the code uses "is checked empirically". Before building a conformal statistic on it, test whether (1 - alpha)^n can fail for disjoint pairs. experiments/theory/disjoint_check.py (about 100 s, no flow): exact counts of n-matchings inside a graph H of good pairs.
• Predictions (fixed now): (1) P(all n disjoint pairs in H) exceeds d^n for some small graph (the independent-pairs argument cannot be a general fact). (2) At the claim's threshold (d < 0.8, alpha = 0.2) a hill-climb over H at N = 10 to 12 finds no violation. (3) A bad clique and bad hub points at N = 50 are conservative. Each is refuted by the opposite.

### Outcome (experiments/theory/disjoint_results.txt)

• (1) held. N = 6, n = 3: P up to 8.3 d^n (d = 0.2); N = 7, n = 3: 3.3; N = 4: 3.0 (exhaustive for N <= 6, 300,000 random graphs for N = 7). The general statement is false.
• (2) held, narrowly. Best found P / (1 - alpha)^n is 0.94 to 0.97 at N = 12 (0.255 against 0.262 at n = 6); no violation, but the margin closes as 2n approaches N, so a proof would need to use that pilots are small against the pool.
• (3) held. Clique ratio to bound at most 0.97 (n = 8) and 0.77 (n = 22); hubs at most 0.94 and 0.29.
• Reading: the rigorous statement is the independent-pairs one (draw pairs with replacement of points; cost at most 2n, same bound). QUANTILE.md now says so and the paper should quote that scheme or label the disjoint coverage empirical. This does not touch the weakness already logged: a bound on the share of bad pairs is not a regret bound.
• Limits: hill-climb is a search, not a proof; N <= 12 for the adversarial search; coverage of the with-replacement scheme not re-measured.
• Next: re-measure coverage for the with-replacement pilot on the cached tables, then the regret-side theorem (pairs involving the optimum), which is the real gap.

2026-10-28 · Milestone 34: median, worst-design and tail regret for every arm, budget and design set (descriptive; predictions fixed before the script ran)

• Why: milestone 33 ended with "report worst-design regret and medians for all arms in the paper". Means over 12 designs are carried by one or two cells (bcastmix192, bcastadd64), and the log has quoted medians only post hoc at one budget. experiments/tail_risk/tail.py re-runs the milestone 33 replay in process (deterministic; same seeds, costs, pools) and tabulates, for rand / adp15 / adp3 / area3 at 10, 15, 25, 40 equivalents, over the 12 designs (clock-averaged): mean, median, worst design, and the number of designs with regret above 5%. No flow run, no tests, no tuning.
• Predictions (fixed now): (1) At 25 equivalents the median over designs ranks adp3 < adp15 < rand (the 0.31 / 0.76 / 1.21 of milestone 33), and at 40 equivalents adp15 has the lowest median. (2) The worst design at 25 and 40 equivalents is bcastmix192 for adp3 and area3, and is under 5% for adp15. (3) Counted over designs with regret above 5% at 40 equivalents, adp15 has none and adp3 at least one. Each is refuted by the opposite.
• Limits known in advance: descriptive only; same 12 designs I chose; ties in medians at 0.00 at large budgets will hide differences.

### Outcome (experiments/tail_risk/: tail.py about 15 s, results.txt, summary.json; no flow run)

• (1) half held. At 25 equivalents the medians are adp3 0.31 < adp15 0.76 < rand 1.21 (area3 0.29), as in milestone 33. At 40 the medians of adp15, adp3 and area3 are all 0.00 (rand 0.35), so "adp15 lowest" is a three-way tie, not a result.
• (2) half refuted. adp3's worst design is bcastmix192 at every budget from 10 to 40 (47.4 to 49.9%). area3's worst is bcastadd64 (61.1 to 68.0%), not bcastmix192: the two R2 scorings break on different designs. adp15's worst is 8.25% at 10 equivalents (rotmix64), 4.85% at 15 and 1.40% at 25 (decmux64), 0.57% at 40 (gf2mat48).
• (3) held. Designs above 5% regret at 40 equivalents: rand 0, adp15 0, adp3 1, area3 1. At 10 equivalents the picture reverses on count: rand has 4 designs above 5%, adp15 3, adp3 2, area3 2, because a harsh cut helps the typical design while the one hostile design costs 47 to 68 points.
• Reading: adp15 is the only arm whose worst design improves monotonically with budget (8.3 / 4.9 / 1.4 / 0.6) and the only one with no design above 5% from 15 equivalents up; eta = 3 has the better median from 15 equivalents (0.85 against 1.87 at 15) and a worst-case that no budget repairs. The paper's claim should be stated as a median-and-tail trade, with means shown only beside worst-design regret.
• Limits: descriptive, 12 designs I chose; the 5% threshold is arbitrary (fixed before the run); medians tie at 0.00 at large budgets.
• Next: put this table into PAPER.md (done in this entry's commit as one paragraph); more held-out designs remain blocked on OpenROAD.

2026-10-28 · Milestone 33: does the R2 score matter once the first cut is harsh (eta = 3)? (predictions fixed before the script ran)

• Why: milestone 32 ended with "the eta = 1.5 insensitivity might not hold with a harsher first cut". At eta = 1.5 two thirds of the points survive R2, so any ordering keeps the best; at eta = 3 only a third do, so the R2 ordering should start to bite. Replay experiments/r2_harsh_cut/replay.py: milestone 32's design (12 held-out designs, 400 paired seeds, costs, pools, regret averaged over the two clocks) with arms random R4, adp15, adp3 (halving eta 3, R2 scored area x period) and area3 (same, R2 scored by mapped area). Tests fixed now: area3 vs adp3, adp3 vs rand, area3 vs rand, adp3 vs adp15 at 10, 15, 25, 40 equivalents; exact Wilcoxon over 12 designs, Holm over 16 tests, bootstrap CI over designs. No flow run; nothing tuned.
• Predictions (fixed now): (1) adp3 has higher mean regret than adp15 at 25 equivalents (a harsher cut loses more of the best points where R2 is wrong), by at least 0.1 points. (2) area3 and adp3 differ by at least 0.15 points at 25 equivalents in mean (the R2 score finally matters), in either direction. (3) On fanao96 and bcastmix192 area3 beats adp3 at 25; on bcastadd64 area3 loses to adp3. Each is refuted by the opposite.
• Limits known in advance: observational replay on tables I produced; 12 designs I chose; area-alone rule picked after seeing fanao96, so those cells are not held-out for it; one corner and tool version.

### Outcome (experiments/r2_harsh_cut/: replay.py 12 s, results.txt, summary.json; no flow run)

• Mean regret % over the 24 cells at 10 / 15 / 25 / 40 equivalents: random R4 5.12 / 3.59 / 1.86 / 0.63; adp15 3.55 / 2.13 / 0.65 / 0.05; adp3 6.83 / 5.38 / 4.67 / 4.63; area3 7.77 / 6.72 / 5.94 / 5.86. On the mean, eta = 3 is worse than random R4 and does not improve with budget (4.6 at 25 and at 40), so the loss is not a budget shortage: the cut throws away the best point.
• (1) held. adp3 minus adp15 is +4.02 points at 25 (CI [-0.55, +12.57], Holm p = 1.0). (2) held, in the bad direction. area3 minus adp3 is +1.27 at 25 (CI [-12.55, +16.74], Holm p = 1.0): scoring R2 by area alone costs more once the cut is harsh. (3) half refuted. bcastmix192: area3 0.00 against adp3 49.85 (held, the binary swap again); bcastadd64: area3 67.99 against 0.18 (held); fanao96: both 0.00 at 25 (refuted: no gain, since adp3 already finds the best there).
• The means are two single-design catastrophes, not a typical effect. At 25 equivalents adp3's regret is 0.00 on five of 12 designs and 0.18 to 0.57 on four more, with 49.85 on bcastmix192 and 2.89 on crc32. Medians over the 12 designs (post hoc, read off the per-design lines in results.txt): adp3 0.31, adp15 0.76, random R4 1.21. Excluding bcastmix192 (post hoc): means 0.56, 0.71 and 2.03. So a harsh cut is the best typical-case arm and the worst tail: it wins on cmp128, rotmix64, xbar16, decmux64 (0.00 to 0.41 against 0.79 to 1.40 at eta = 1.5) and loses on one degenerate design and on crc32.
• Nothing is corrected-significant: the design-level distribution is heavy-tailed and the exact Wilcoxon over 12 designs cannot see it (smallest Holm p 1.0 throughout). The sign counts at 25 (adp3 better than adp15 on 8, worse on 3 by the 0.05 threshold) are a descriptive pattern, not a test result; a signed-rank test on a distribution with one 50-point outlier is dominated by that outlier.
• Reading: milestone 32's "any ordering keeps the best at eta = 1.5" is confirmed from the other side. At eta = 3 the R2 score matters, and area alone is the worse score; the R2 rung is safe to use only gently, and the paper's tail-risk argument for f3 (do not cut on R2) is strengthened: the harsher the cut, the more the result depends on whether the design is one of the R2-hostile ones, which is what the pilot gate tried and failed to detect. A mean-regret table hides this, so the paper should report medians and worst-design regret beside means.
• Limits: observational replay on tables I produced; 12 designs I chose, two of which carry the tails; the median and exclusion figures are post hoc; one corner and tool version; no tuning of eta (3 is the next integer above the milestone 16 sweep's gentle end).
• Next: report worst-design regret and medians for all arms in the paper (a script over the existing summary), or more held-out designs (needs OpenROAD, absent in this session).

2026-10-28 · Milestone 32: does ranking the R2 rung on mapped area alone beat area x period on the 12 held-out designs? (predictions fixed before the script ran)

• Why: milestone 31 found that on fanao96 the routed period is set by a wire/fanout floor the mapped netlist cannot see, while area survives routing (tau 0.98), and suggested ranking R2 on area alone. Replay experiments/r2_area_arm/replay.py: the milestone 29 design (400 paired seeds, costs, pools and regret as milestone 16; regret averaged over the two clocks so the design is the unit) on all 12 designs never used to choose eta (unseen 5, hostile 5, fanout_rich 2). Arms: random R4, adp15 (halving eta 1.5, R2 rung scored area x period) and area15 (same, R2 rung scored by mapped area; R3 and R4 rungs unchanged). Tests fixed now: area15 vs adp15, area15 vs rand, adp15 vs rand at 10, 15, 25, 40 equivalents; exact Wilcoxon over 12 designs (smallest p 0.0005), Holm over 12 tests, bootstrap CI over designs. No flow run; no parameter tuned.
• Predictions (fixed now): (1) full-pool R2 pick regret on fanao96 drops by at least half under area alone (13.7 / 14.6% in milestone 30). (2) Mean full-pool tau(R2, R4) over all cells is lower under area alone, because period carries signal on the 10 designs where R2 works (milestone 18). (3) At 25 equivalents the mean regret of area15 and adp15 differ by under 0.15 points, i.e. no average gain: area alone helps the hostile cells and costs the others. Each is refuted by the opposite.
• Limits known in advance: observational replay on tables I produced; 12 designs; a rule picked after seeing the mechanism on fanao96, so the fanao96 cells are not a held-out test of it (the other ten designs are); one corner and tool version.

### Outcome (experiments/r2_area_arm/: replay.py 9 s, results.txt, summary.json; 24 cells)

• (1) held. fanao96 full-pool R2 pick regret falls from 13.7 / 14.6% to 0.0 / 0.0% under area alone, and bcastmix192 from 49.9% to 0.0% (tau -1.00 to +1.00; with two outcome classes this is the same binary swap as before, reversed). Both are cells I looked at before choosing the rule, so neither is a held-out test of it.
• (2) refuted, and the cost is large. Mean full-pool tau(R2, R4) over the 24 cells is higher under area alone (0.58 against 0.38), but mean full-pool R2 pick regret is worse (10.3% against 6.0%). Area alone is a bad argmin: bcastadd64 goes from 0.0 / 0.4% to 50.6 / 95.3% (tau 0.80 / 0.73 to -0.21 / -0.09), decmux64 relaxed 0.0 to 23.5%, cmp128 0.0 to 13.6 / 11.3%. A fix for the wire-floor designs breaks the designs where period carries the signal, which is the trade I expected to find in (3) but did not expect to see so sharply in the pick regret.
• (3) held, trivially. In successive halving at eta = 1.5 the two R2 scorings are indistinguishable: mean regret difference (area15 minus adp15) +0.12 / +0.02 / +0.00 / +0.00 points at 10 / 15 / 25 / 40 equivalents, designs better/worse 2/4, 2/2, 0/0, 0/0, all Holm p = 1.0. At 25 the two arms differ by under 0.01 points on every one of the 12 designs. The reason is that eta = 1.5 keeps two thirds of the points after R2, so almost any ordering keeps the eventual best; the R2 rung is a coarse filter, and which score it uses barely matters. The comparison against random R4 repeats milestone 29 on 12 designs: both arms beat random R4 by 1.2 to 1.6 points at 10 to 25 equivalents, 9 or 10 designs of 12 better, and now Holm-significant at the first three budgets for area15 (0.012, 0.022, 0.044) and adp15 (0.044, 0.034, 0.044) at the 0.05 level, but not at 40 (0.082). This is the first corrected-significant version of the held-out win; the ten-design test of milestone 29 was not. Caveat: two of the twelve designs (fanao96, bcastadd64) were added after milestone 29, and the set is still designs I chose.
• Reading: the "rank on area alone" fix is right for the cells where the routed period is a floor and wrong everywhere else, so as an argmin it is not a replacement for area x period; inside halving it changes nothing measurable. The mechanism in milestone 31 is real but it does not need a fix, because gentle halving already absorbs a bad R2 ranking. That sharpens the paper's claim: the benefit comes from keeping many points past R2, not from the R2 score.
• Limits: tables I produced; 12 designs; Holm over 12 correlated tests; the fanao96 and bcastmix192 improvements are on the cells that motivated the rule; one corner and tool version; the eta = 1.5 insensitivity might not hold with a harsher first cut (eta = 3), which this replay did not test.
• Next: the same replay at eta = 3 and "f3" first cuts, where R2 ordering matters more; or more held-out designs (needs OpenROAD).

2026-10-27 · Milestone 31: which factor of the area-delay product does R2 get wrong on fanao96? (post hoc: the script was written after milestone 30's data existed; no flow run, no tuning)

• Why: milestone 30 left the mechanism open. R2 and R4 scores are ADP = area x (clock - WNS), so the mis-ranking sits in the area factor, the period factor or both. experiments/fanao_mech/analyse.py reads fanout_rich/results.jsonl and reports tau-b of each factor between rungs, and tau-b of three repair quantities (buffers added, area growth, period recovered by repair) against each sequence's R2-to-R4 rank shift.
• Prediction written before the output: the period factor carries the error (milestone 18 found that on earlier designs), and buffers added track the shift. The second half is refuted below.

### Outcome (experiments/fanao_mech/results.txt)

• fanao96: area is nearly preserved from mapping to routing (tau area R2,R4 = 0.98 in both cells; area growth x1.00 to 1.02), while period is not (tau 0.12 relaxed, 0.21 tight). The mapped period spans 0.58 to 3.88 ns; the routed period spans only 1.1 to 2.85 ns (relaxed) and 1.1 to 2.07 ns (tight). Mapping differences in logic depth are compressed by wiring and a fanout-96 floor, so the R2 spread is mostly not seen at R4.
• bcastadd64 (R2 works, tau 0.73 to 0.80): mapped and routed periods keep their order (tau 0.51 to 0.74) and the spread survives (3.44 to 12.54 mapped, 3.5 to 11.5 routed).
• Buffers added do not track the shift (tau -0.16, -0.19; 0 to 4 buffers on fanao96), so the repair-by-buffering story from milestone 28 is not what drives fanao96: the mechanism there is a wire/fanout period floor, not buffer insertion. Period recovered by repair tracks the shift at tau -0.78 and -0.76, but that is partly circular (recovery is R2 period minus R4 period, and both enter the rank shift), so I read it as consistent with the floor, not as independent evidence.
• Reading: R2 fails where the routed period is set by something the mapped netlist cannot see (a wire-dominated floor), and area is not the problem. That fits milestone 18 and suggests a cheaper fix than a pilot gate: rank on R2 area and treat R2 period as uninformative on high-fanout designs. Not tested here.
• Limits: observational, one design pair, 50 sequences per cell; the correlation of recovery with shift is partly built in; no flow rerun with the floor removed (a causal test would re-route the same netlists at several fanouts); tau values carry no intervals.
• Next: test "rank on R2 area alone" as an arm in the replay on all held-out tables, or vary the fanout of fanao (24, 48, 96, 192) to see the floor move.

2026-10-27 · Milestone 30: does repair-driven inversion (milestone 28) show up, with statistics, on high-fanout designs whose sequences give many distinct mappings? (predictions fixed before any flow output exists)

• Why: milestone 28's "Next" and paper section 6 item 2: bcastmix192 has two outcome classes, so its tau = -1 and 49.9% regret rest on one binary swap. Two new combinational designs with high-fanout controls and enough logic that ABC passes should differ: bcastadd64 (four 64-fanout controls gating four permuted 64-bit words, summed by +) and fanao96 (eight one-hot controls of fanout 96 selecting among eight permuted words by AND-OR, then a neighbour XOR). Protocol of milestone 28 unchanged (60 sequences from the same seed, clocks 1.0x and 1.5x the baseline's no-wire period, four rungs, tt corner, 40% utilisation, OpenROAD 26Q2 from the nixpkgs cache, Yosys from apt): experiments/fanout_rich/run.py, 240 flow runs; analysis analyse.py computes distinct outcomes, tau(R2,R4) and R2 pick regret per cell. Both designs are kept whatever they show.
• Predictions (fixed now): (1) each of the four cells has at least 8 distinct routed scores among its successful sequences (the richer-outcome goal is met; if not, the design fails its purpose and that is the result). (2) R2 pick regret exceeds 10% in at least one cell. (3) Mean tau(R2,R4) over the four cells is below 0.5 (milestone 27: 0.70). Each is refuted by the opposite.
• Limits known in advance: two designs chosen by me; yosys version differs from the earlier 0.33 if apt now ships another, which I will state; one corner.

### Outcome (experiments/fanout_rich/: run.py about 40 min on 4 cores, results.jsonl 240 runs, 200 ok and 40 failed in ABC (10 per cell), analyse.py -> outcomes.txt, replay.py -> results.txt; Yosys 0.33, OpenROAD 26Q2 from the nixpkgs cache, as before; baseline no-wire periods 3.60 and 2.07 ns)

• (1) held. 36 to 37 distinct R2 scores and 38 to 39 distinct routed scores per cell among 50 successful sequences, against 2 for bcastmix192. The statistics milestone 28 could not run are now possible.
• (2) held, and it is a real bad design this time. fanao96 has R2 pick regret 13.7% (relaxed) and 14.6% (tight) with tau(R2,R4) 0.14 and 0.20; bcastadd64 is at 0.0 / 0.4% with tau 0.80 / 0.73. So R2 failure on a high-fanout design does not need a binary swap: a many-outcome design (fanout 96, AND-OR of eight permuted words) mis-ranks as well. I did not test why (repair inversion is a hypothesis from milestone 28, not shown here).
• (3) held, narrowly. Mean tau(R2,R4) over the four cells is 0.47 (below 0.5), a mean of two very different designs (0.77 and 0.17), not a typical value.
• Replay (mean regret % over four cells at 10 / 15 / 25 / 40 equivalents): random R4 3.97 / 2.13 / 0.73 / 0.15; eta = 1.5 2.21 / 0.77 / 0.13 / 0.00; f3 1.96 / 0.84 / 0.18 / 0.09; best gate (R4, theta 0.7) 2.74 / 1.01 / 0.19 / 0.01; oracle gate 1.88 / 0.76 / 0.11 / 0.00. Even with a bad cell present, a gentle cut and f3 both beat random R4, and the gate does not beat them at any budget (its five-point pilot costs 0.5 to 0.8 points at 10 to 15). The pilot statistic separates the two bad from the two other cells (AUC 1.00, pilot tau 0.16 against 0.74) but with within-cell sd 0.34 and two positive cells that is no evidence of a usable detector, as in milestone 28.
• Reading: the gate's detection side is still unpaid for, now with a bad design that has a rich outcome set; and R2 pick regret of 14% sits beside a halving result that is still good, because halving keeps many points to R4 rather than trusting the R2 argmin.
• Limits: two designs chosen by me; four cells (so two independent designs); 40 of 240 runs failed in ABC; one corner and tool version; no significance test; no mechanism study for why fanao96 mis-ranks.
• Next: a mechanism check on fanao96 (which cells or nets reorder between R2 and R4), or more held-out designs to reach n = 20.

2026-10-27 · Milestone 29: are the held-out wins of "cut on R2 gently" over random R4 significant when the ten unseen and hostile designs are pooled? (post hoc: the script ran once before this entry was written; comparisons and tests were fixed in the script's header, not tuned afterwards)

• Why: milestones 27 and 28 each said "no significance test run" and reported means over 10 cells. Pooled the two tables (10 designs, never used to choose eta or the gate) and tested fixed eta = 1.5 and f3 against random R4, and f3 against eta = 1.5, at 10, 15, 25, 40 equivalents. Cost model, pools, 400 paired seeds and regret as milestone 16; regret averaged over the two clocks per design (the clocks share a design, so the design is the unit); exact two-sided Wilcoxon over 10 designs (smallest attainable p 0.0020), Holm over the 12 tests, bootstrap CI over designs. experiments/heldout_signif/test.py, about 100 s, runs no flow.
• Expectation written down from the two earlier outcomes: arms beat random at 25 and 40; f3 and eta = 1.5 differ by under 0.1 points.

### Outcome (experiments/heldout_signif/: results.txt, summary.json)

• Mean regret difference against random R4 at 10 / 15 / 25 / 40 equivalents: eta = 1.5 -1.53 / -1.48 / -1.33 / -0.67 points (designs better/worse 8/1, 8/2, 8/1, 8/1; bootstrap CIs exclude 0 at all four; raw Wilcoxon p 0.012 to 0.027); f3 -1.42 / -1.38 / -1.32 / -0.63 (7 or 8 better, 1 or 2 worse; raw p 0.027, 0.027, 0.039, 0.074).
• After Holm over 12 tests nothing is significant (smallest adjusted p 0.14, eta = 1.5 at 25). With ten designs the exact test cannot clear a 12-test correction unless nearly every design agrees; the effect is consistent in sign (8 of 10 designs better) and the bootstrap intervals exclude zero, but the claim "gentle halving beats random R4 on unseen families" is supported at the uncorrected level only.
• f3 against eta = 1.5: differences of +0.11, +0.10, 0.00, +0.04 points (f3 slightly worse or equal); the one uncorrected hit is budget 15 (p 0.014, Holm 0.15), an effect of a tenth of a point. At 25 the two are indistinguishable (3 better, 4 worse, p 1.0).
• Two designs carry the disagreement: gf2mat48 is the only one where random R4 beats both arms (0.32 against 0.73 and 0.70) and crc32 is a near tie; bcastmix192 is 0.00 for every arm (two outcome classes, so any three routed points find the best), so it adds a zero to every comparison and dropping it moves the means by about 10% (last column).
• Reading: the held-out evidence for gentle R2 halving over random R4 is a consistent but modest effect, one design in ten the other way, not corrected-significant at n = 10; and the choice between eta = 1.5 and f3 is a coin flip at 25 equivalents, so f3's value is as insurance against R2-bad cells, not an average gain. The paper's wording should say "uncorrected" where it quotes the held-out win.
• Limits: ten designs, chosen by me; two clocks averaged (so one design, one observation); Holm over 12 correlated tests is conservative; per-design regret is the mean over 400 seeds, so the seed noise is already averaged out and the test is over design-level variation only; one corner and tool version.
• Next: a high-fanout design with many distinct mappings (needs OpenROAD), more held-out designs to reach n = 20 (needs OpenROAD), or typesetting.

2026-10-27 · Paper: milestones 24 to 28 folded into the results (no new experiment)

• Why: milestone 28's "Next" named the corrected paper section 6. PAPER.md carried milestones 24 to 28 only as bracketed notes in the to-do list. Added a Section 3 paragraph (larger designs, 65% utilisation, ss corner, held-out families, R2-hostile designs) with every number copied from the committed results files, and rewrote section 6 as a clean list. Spot-checked the hostile and unseen figures against results.txt. Limits: the arXiv ids could not be re-checked (cite_check.py got 403 from the proxy; none are new); the flow tools are absent in this session, so no new runs.
• Next: a high-fanout design with many distinct mappings (needs OpenROAD), or typesetting.

2026-10-27 · Milestone 28: does R2 fail, and does the pilot gate then pay, on designs built to be wiring-dominated? (predictions fixed before any flow output exists)

• Why: milestone 27's "Next". Its five hand-picked families held no bad R2 cell, so the gate's detection side (flag a cell where the R2 rank misleads, then stop cutting on R2) is untested: milestones 16 and 17 fitted the gate on cells whose bad ones are barrel16, fifo8x4, barrel64 and the multipliers. Five new combinational designs written to make mapped-netlist timing a poor guide to routed timing, by wire length and fanout rather than logic depth: xbar16 (16 ports x 8 bits, each output with its own 4-bit select), gf2mat48 (dense 48x48 GF(2) matrix-vector product from an LFSR-generated matrix, each input feeding about 24 XOR trees), bcastmix192 (three controls each with fanout 192 gating a permuted 192-bit word), cmp128 (128-bit less-than and equality), rotmix64 (64-bit rotate XOR a masked second rotate). Protocol of milestone 27 unchanged (60 sequences from the same seed, clocks 1.0x and 1.5x the baseline's no-wire period, four rungs, tt corner, 40% utilisation, OpenROAD 26Q2, Yosys 0.33): experiments/hostile/run.py, 600 flow runs; replay experiments/hostile/replay.py is milestone 27's with the table swapped, nothing tuned. I chose the designs by structural argument before seeing any output, and keep all five whatever they show.
• Predictions (fixed now): (1) R2 pick regret exceeds 10% in at least 2 of the 10 cells (these families do carry bad cells). (2) Mean cell tau(R2,R4) is below 0.60 (milestone 27: 0.70; milestone 16 other cells: 0.69). (3) f3 beats fixed eta = 1.5 at 25 equivalents, reversing milestone 27. (4) The best pilot gate beats f3 by at least 0.1 points at 25 (the gate pays when bad cells exist). Each is refuted by the opposite.
• Limits known in advance: five designs, ten cells, one corner and tool version; designs chosen by me, and "built to make R2 fail" is my structural guess, not a tested property; some of these may be too big for a fast flow, in which case a smaller parameter is used and said so.

### Outcome (experiments/hostile/: run.py about 100 min on 4 cores, results.jsonl 600 runs of which 520 ok and 80 failed in ABC, replay.py 13 s, results.txt; designs xbar, gf2mat, bcastmix, cmp128, rotmix in designs/, all five kept; baseline no-wire periods 1.10, 1.35, 6.52, 1.51, 2.42 ns)

• Mean regret % over the 10 cells at 10 / 15 / 25 / 40 equivalents: random R4 6.51 / 4.72 / 2.81 / 1.10; fixed eta = 1.5 4.29 / 2.67 / 0.74 / 0.11; f3 4.26 / 2.69 / 0.67 / 0.11; best pilot gate (R4, theta 0.7) 5.18 / 3.20 / 1.05 / 0.08; oracle gate 4.08 / 2.64 / 0.67 / 0.11.
• (1) held on the letter, but it is one design. R2 pick regret exceeds 10% in 2 of 10 cells, both bcastmix192 (49.9% at both clocks). The other eight cells are at most 1.1%. So the family built to be wiring-dominated produced one bad design in five, not a bad family.
• The bad cell is degenerate. bcastmix192 has only two distinct outcomes across its 60 sequences (two ABC mappings: R2 ADP 30,283 and 48,581; routed ADP 12,498 and 8,340). The mapping with the worse mapped timing (6.52 ns, 2 buffers added in repair) routes better (1.11 ns against 1.48 ns), so R2 ranks them exactly backwards: tau(R2,R4) = -1.0 on both clocks, 49.9% regret from one binary swap. A real inversion of the mapped-timing signal by repair (a high-fanout net that repair_design buffers), but with two points per cell there is no statistics to run on it.
• (2) held. Mean full-pool tau(R2,R4) over the 10 cells is 0.02 (0.28 over the other eight; per cell 0.12 to 0.56), against 0.70 on milestone 27's designs. The R2 signal is weaker on all five of these designs, not only on bcastmix192: the tight-clock taus are 0.56 (cmp128), 0.51, 0.29, 0.20, and the relaxed ones 0.12 to 0.23, yet R2 still picks well (regret 0 to 1.1%), so a low tau does not by itself mean a bad pick.
• (3) held, narrowly. f3 0.67 against fixed eta = 1.5 at 0.74 at 25 equivalents; the 0.07 gap is under the 0.1 that seed noise leaves unresolved, and the two are equal at 40 (0.11). No significance test run.
• (4) refuted. The best gate is worse than f3 at 25 by 0.38 points (1.05 against 0.67), and the oracle gate equals f3, so there was nothing for a gate to gain here either. The pilot statistic does separate the cells (AUC 1.00, 2 bad against 8 other, pilot tau -1.00 on the bad cells against 0.30), but with a mean within-cell sd of 0.32 on the other cells the five-point pilot often falls below theta on a good cell and the gate takes f3 or a wrong arm at cost. AUC from 2 positive cells is not evidence of a usable detector.
• Reading: the detection side is still not shown to pay. With one real bad design the oracle is f3, and a no-R2-cut policy (f3) is as good as anything at 25 and 40; the gate only costs its pilot. What the step adds is a mechanism for how R2 can fail that earlier bad cells (barrel, multipliers) did not show: repair-driven inversion, where timing repair rescues the mapping that looked worst. The paper's negative headline on small designs stands.
• Limits: five designs chosen by me; two bad cells that are one design with two outcome classes; 80 of 600 runs failed in ABC (milestone 27: 98); one corner and tool version; no significance test; the AUC rests on 2 positive cells.
• Next: check whether repair-driven inversion occurs on designs with a richer outcome set (a high-fanout design whose sequences give many distinct mappings), or the corrected paper section 6 for the programme's draft.

2026-10-27 · Milestone 27: does the pilot-gate picture (milestone 16) hold on five designs from families it never saw? (predictions fixed before the flow output was opened)

• Why: milestones 24 to 26's "Next" and paper section 6: every gate, halving and f3 result was fitted or chosen on the same 20 designs (the milestone 16 limits say so), so the "do not cut on R2 (f3)" recommendation has not met a held-out design family. Five new combinational designs, none a multiplier, adder, shifter, popcount or ALU: crc32 (parallel CRC-32, XOR tree), prio64 (64-bit priority encoder), sort8x8 (8-key odd-even merge sorting network, comparators and muxes), sbox (AES S-box as a 256-entry lookup; table generated from the GF(2^8) inverse and checked at 0x00, 0x01, 0x53, 0xff), decmux64 (6-to-64 decoder and 64:1 AND-OR mux, wiring-dominated). Protocol of milestone 15 unchanged (60 sequences from the same seed, clocks at 1.0x and 1.5x the baseline's no-wire period, four rungs, tt corner, 40% utilisation, OpenROAD 26Q2, Yosys 0.33): experiments/unseen/run.py, 600 flow runs. Replay: experiments/unseen/replay.py is pilot_gate/gate.py with the table swapped (same rules, thetas 0.3, 0.5, 0.7, pilot 5, 400 seeds, budgets 10, 15, 25, 40 equivalents); nothing is tuned on the new table.
• Predictions (fixed now): (1) Tight-clock R2 pick regret exceeds 10% on at least one of the five designs (the R2 bias is not confined to the families seen so far). (2) At 25 and 40 equivalents, mean regret over the 10 cells of f3 is at or below random R4's (the milestone 16 ordering at 25; its tie at 40 is within noise, so I only commit to 25). (3) The best pilot gate beats f3 by under 0.1 points at 25 (milestone 16's margin carries over: the gate is not worth its pilot). (4) Fixed eta = 1.5 is worse than f3 at 25 on the 10 cells. Each is refuted by the opposite.
• Limits known in advance: five designs, ten cells, one corner and tool version; the designs were chosen by me for variety, not drawn from a population; the cost of a routed point on these small designs may be low (few seconds), as in milestone 15.

### Outcome (experiments/unseen/: run.py about 35 min on 4 cores, results.jsonl 600 runs of which 502 ok and 98 failed in ABC (about the same share as earlier tables), replay.py about 1 min, results.txt, summary.json)

• Mean regret % over the 10 cells (5 designs x 2 clocks) at 10 / 15 / 25 / 40 equivalents: random R4 4.19 / 3.04 / 1.36 / 0.35; fixed eta = 1.5 3.35 / 2.14 / 0.77 / 0.00; f3 3.60 / 2.31 / 0.85 / 0.07; best pilot gate (R3, theta 0.3) 3.78 / 2.35 / 0.85 / 0.02.
• (1) refuted. No unseen design has R2 pick regret above 10% at the tight clock: the largest is crc32 at 9.3%, then sort8x8 0.4%, the rest 0.0%. At the relaxed clock the largest is sbox at 3.9%. These five families carry none of the bad cells that drove milestones 9, 13 and 15 (barrel64, mult24/32, alu32).
• (2) held. f3 beats random R4 at 25 equivalents (0.85 against 1.36); at 40 both are near zero (0.07 against 0.35).
• (3) held, trivially. The best gate (R3, theta 0.3) equals f3 at 25 (0.85); the other gates are worse by 0.02 to 0.07. The gate does not pay for its pilot here either.
• (4) refuted. Fixed eta = 1.5 beats f3 at every budget (0.77 against 0.85 at 25, 0.00 against 0.07 at 40), on both clocks. With no bad cells the "never cut on R2" policy costs about 0.1 points of regret and halving is as good as the oracle gate, which is the milestone 16 oracle's picture turned around: the cost of f3 is the price of insurance against cells these designs do not contain.
• Pilot statistic: mean cell tau(R2,R4) is 0.70 and tau(R2,R3) 0.72 on all ten cells (against 0.69 for the "other" 28 cells of milestone 16), within-cell sd 0.24 and 0.23. With no bad cells there is no AUC to report.
• Reading: the held-out result is consistent with the programme's account, not a confirmation of f3 as universal: where R2 ranks well, a gentle cut is slightly better; where it does not, f3 is the safe choice, and a five-point pilot does not separate the two cases well enough to gate (milestone 16). Five hand-picked designs with no bad cell cannot test the gate's detection side; that needs designs where R2 fails, which are rarer than I assumed (3 of 25 designs at the tight clock now).
• Limits: five designs, ten cells, chosen by me; one corner and tool version; 98 sequences fail in ABC and drop out; the oracle comparison is in-sample by construction; differences under about 0.1 points are inside seed noise; no significance test run.
• Next: a design family built to make R2 fail (long-wire, heavily buffered or high-fanout structures) to test the gate's detection side, or the larger designs at the ss corner.

2026-10-27 · Milestone 26: do the halving and never-cut strategies of milestone 13 keep their ranking on the ss table, and does an eta chosen at tt transfer? (predictions fixed before reading any output; the script was started first and its output not opened)

• Why: milestone 24's "Next" and paper section 6 item 2 ("a replay of the strategies on the ss table"). Same cost model, pools, 400 paired seeds, strategy grid (eta 1.1 to 3, f2, f3) and regret as milestone 13 (experiments/eta_floor/sweep.py), run on experiments/corner_ss/results.jsonl (ten small designs, two clocks, budgets 10, 20, 30, 45 s). experiments/corner_replay/replay.py is that script with the table swapped, rerunning tt in the same process, and a cross-corner section: eta chosen as best mean over the ten tt designs, scored on the ss pools. Runs no flow.
• Predictions (fixed now): (1) At ss, chosen-eta halving still beats random R4 at the tight clock at 20 s and above (mean held-out regret lower), as at tt. (2) At ss relaxed, chosen-eta halving is still not better than random R4 at 45 s (the floor of milestone 13 persists), because R2 mis-ranks the same barrel16/fifo8x4-type cells (milestone 24). (3) The eta taken from tt is within 0.5 points of ss's own best fixed eta at every budget and clock. Each is refuted by the opposite.
• Limits known in advance: liberty-only corner, ten small designs, paired subset drops sequences that failed at either corner (pools of 50 to 52), one tool version.

### Outcome (experiments/corner_replay/: replay.py about 100 s, results.txt, summary.json; no flow run; the tt half reproduces eta_floor/results.txt line for line, a check on the swap)

• Mean held-out regret % over the ten designs (chosen eta, leave-one-design-out) against random R4, ss table. Tight: 6.75 vs 6.45 at 10 s, 3.32 vs 3.40 at 20 s, 2.36 vs 1.91 at 30 s, 1.35 vs 0.75 at 45 s. Relaxed: 4.84 vs 5.12, 2.20 vs 2.63, 1.34 vs 1.48, 0.59 vs 0.59.
• (1) refuted. At the ss tight clock chosen-eta halving beats random R4 only at 20 s (by 0.08 points) and loses at 30 and 45 s (paired wins/losses 1/1 and 0/1). At tt it won at every budget (5/0 to 7/1). The best fixed eta at ss tight is 1.1 (the gentlest cut), 3.17, 1.65, 0.63 at 20, 30, 45 s, i.e. about random.
• (2) held on the letter, wrong on the mechanism. Chosen-eta regret at ss relaxed 45 s equals random (0.59), so it is not better; but the reason is not a persisting floor: eta = 2 reaches 0.25 against 0.59 for random and wins on 8 of 10 designs (loses 1), and chosen eta at 20 s and 30 s beats random (6/1, 8/1). Relaxed at tt was the bad clock (chosen 1.40 against random 0.55 at 45 s); at ss it is the good one. Which clock halving helps on flips with the corner.
• (3) refuted. The eta picked on tt is within 0.5 points of ss's best fixed eta at relaxed (0.06, 0.23, 0.30, 0.04) but not at tight at 30 and 45 s (0.58, 0.54); at tight it also loses to random R4 at 20, 30 and 45 s (3.67, 2.23, 1.16 against 3.40, 1.91, 0.75), while at relaxed it beats random at every budget (4.90, 2.43, 1.33, 0.29 against 5.12, 2.63, 1.48, 0.59).
• Reading: the milestone 13 to 16 result (halving from R2 with a gentle eta helps on small designs) is corner-dependent. At ss it is a win for the relaxed clock only, an eta chosen at tt carries over there and fails at the tight clock, where plain random R4 is as good or better from 30 s. So a halving schedule, like the pass sequence itself, has to be tuned (or at least checked with the pilot) at the corner being signed off. This does not rescue the paper's headline, which stays negative on small designs.
• Limits: liberty-only corner; ten small designs; pools of 50 to 52 after pairing; the chosen-eta win/loss counts are per design and not corrected for multiplicity; differences under about 0.15 points are inside seed noise; the large-design table was not replayed at ss (no ss runs of those).
• Next: an unseen design family for the pilot gate (milestone 25's next), or the large designs at ss (needs OpenROAD).

2026-10-27 · Milestone 25: does the rung-bias picture of the five larger designs survive a second operating point (65% placement utilisation)? (planned before running)

• Why: paper section 6 item 1 still lists "a second corner" as a gap, and every milestone so far uses 40% utilisation. Milestone 24 (landed concurrently) covers the ss liberty corner; this one varies placement density, which changes wire length, congestion and what repair_timing must fix, i.e. exactly what the later rungs see and R1 and R2 do not. Same harness as milestone 9 (experiments/large/run.py): mult16, mult24, mult32, adder_op64, adder_ripple64, the same 60 pass sequences, clocks at 1.0x and 1.5x each design's no-wire baseline period, only VDSE_UTIL=65 differs (OpenROAD 26Q2 from the nixpkgs cache, Yosys 0.33 from apt, as in milestone 9). Script experiments/util65/run.py, analysis analyse.py (unchanged).
• Predictions (fixed now): (1) The R2 cut still floors on at least one design at the relaxed clock (median R2 regret over designs stays above 1%), as at 40%. (2) Median R2 regret at 65% differs from the 40% value (2.9% relaxed, 0.8% tight) by under 3 points: the ranking mistakes come from timing repair, not density. (3) R4 wall time per point at 65% is not lower than at 40% (denser placement is not cheaper to route). (4) The number of rejected runs does not fall. Each is refuted by the opposite.
• Limits known in advance: placement utilisation is one axis of a corner, not a PVT corner; same designs and sequences; one tool version.

### Outcome (experiments/util65/: run.py about 85 min on 4 cores, results.jsonl, results.txt, summary.json)

• (1) held. Median R2 regret over the five designs is 2.5% at the relaxed clock and 2.0% at the tight one (both above 1%). The R2 floor stays on mult24 (13.4%) and mult32 (11.2%) at the relaxed clock, against 11.3% and 14.1% at 40% utilisation.
• (2) held. Median R2 regret moved by 0.4 points relaxed (2.9 to 2.5) and 1.2 points tight (0.8 to 2.0), both under 3. Per-design R2 tau at the relaxed clock: mult16 0.35 (0.30 at 40%), mult24 0.56 (0.54), mult32 0.60 (0.57), adder_op64 0.79 (0.76); the confidence intervals overlap throughout.
• (3) held. Mean R4 time per point rose from 19.4 s to 24.4 s (R1, R2, R3 unchanged: 0.81, 1.27 + 0.40, 2.52 s).
• (4) held. Rejected runs: 100 of 600 against 96 (adder_op64 24 against 20).
• Reading: moving from 40% to 65% placement density does not change the rung-bias picture of milestone 9: R1 stays a weak ranker (median tau 0.38 tight, 0.21 relaxed), R2 mis-ranks the same two multipliers at the relaxed clock, and the routed rung costs more, not less. One placement-density axis only; the liberty (ss_100C_1v60) corner is milestone 24's.
• Limits: utilisation is not a PVT corner; same designs, sequences and tool versions; 50 pool points per cell; tau intervals are bootstrap and overlap with milestone 9's.
• Next: an unseen design family for the pilot gate.

2026-10-27 · Milestone 24: does the rung bias survive a second corner (SKY130 HD ss_100C_1v60)? (planned before the analysis; the flow was started first)

• Why: paper section 6 item 2 and every "Next" since milestone 1 name a second corner as the open threat: all results are at tt_025C_1v80. This session has OpenROAD 26Q2 (the plain nixpkgs binary cache build, so no 1.5 h compile) and Yosys 0.33 (apt), so the milestone-1 protocol can be rerun unchanged except for the liberty: same 10 designs, same 60 pass sequences from the same seed, two clocks (1.0 and 1.5 times the baseline's no-wire period, taken from the new corner's own baseline), four rungs (experiments/rung_bias/run.py --lib, output in experiments/corner_ss/). Liberty: sky130_fd_sc_hd__ss_100C_1v60.lib from the efabless mirror of the SkyWater PDK libraries (Apache-2.0; the ORFS platform directory ships only the tt file). The ORFS platform's LEF, tech LEF and RC settings are unchanged, so this changes cell timing only, not wire parasitics.
• Analysis fixed now (experiments/corner_ss/compare.py, pairs points by design, clock tag and pass sequence; runs no flow): per design and clock, Spearman of routed ADP (R4) between corners; Kendall tau of R1 and R2 against R4 at each corner; regret of taking the tt-optimal sequence and using it under ss; whether the argmin is the same.
• Predictions (fixed now): (1) The corner mostly rescales delay, so routed ADP rankings carry over: median Spearman between corners at least 0.9, and the tt-optimal sequence loses a median under 3% under ss. (2) The R2 bias does not shrink: the median |tau(R2,R4)_ss - tau(R2,R4)_tt| is under 0.1 and R2-pick regret exceeds 10% in no more cells than at tt (the count at tt is read from the committed table). (3) The generic-gate rung stays the weakest: median tau(R1,R4) at ss is below that of R2 at ss. Each is refuted by the opposite.
• Limits known in advance: one extra corner (not fast); the ten small designs only (the larger designs are not rerun in this step); wire parasitics unchanged; one tool version.

### Outcome (experiments/corner_ss/: results.jsonl 1,200 runs of which 1,004 ok and 196 failed, the same count as at tt; compare.py, results.txt, summary.json; flow about 40 min on 4 cores)

• Pairing: 50 to 52 sequences per design and clock appear in both tables (a sequence that failed at either corner drops out); 20 cells.
• (1) refuted. Routed ADP rankings do not carry over well: median Spearman between corners 0.69 (min -0.20, barrel16 at the relaxed clock; 0.25 for fifo8x4 tight). The tt-optimal sequence is also optimal under ss in only 8 of 20 cells and loses a median 3.4% (just over the 3% allowed) and up to 27.0% (barrel16 relaxed) when used at ss. A pass sequence tuned at one corner is not safely portable to another.
• (2) half refuted. The median |tau(R2,R4)_ss - tau(R2,R4)_tt| is 0.12, over the 0.1 allowed; median tau(R2,R4) falls from 0.71 (tt) to 0.60 (ss). The second half held: R2-pick regret exceeds 10% in 3 of 20 cells at ss against 7 at tt, though it is worse at ss on barrel16 (18.5 and 24.0%) and fifo8x4 relaxed (16.3%). The bias is corner-dependent, not uniformly larger or smaller.
• (3) held. Median tau(R1,R4) is -0.04 at ss (-0.03 at tt) against 0.60 for R2: the generic-gate rung carries no rank information at either corner.
• Reading: the milestone-1 conclusion (R1 is useless as a screen, R2 is informative but misleads on a minority of design-clock cells) holds at a second corner, but which cells mislead moves (7 to 3 cells over 10%, on different designs), and the optimum itself moves with the corner. The pilot must be run at the corner being signed off.
• Limits: ss_100C_1v60 only, wire parasitics unchanged (liberty only), ten small designs, one tool version, random pass sequences; the paired subset drops points that failed at either corner; halving/f3 not replayed on the ss table yet.
• Next: replay the milestone 13 to 16 strategies (f3, halving, gate) on the ss table.

2026-10-26 · README sync after milestones 20 to 23 (no experiment)

• README.md still said "NSGA-II, BOHB and BO are not yet run" under milestone 1; milestones 20 to 23 ran ridge, GP-EI and TPE baselines (PAPER.md section 5 already reports them). The line now says so and keeps NSGA-II and the full BOHB bracket schedule as not run.
• Open and unchanged: BOHB bracket schedule, larger designs and a second corner (needs OpenROAD, Yosys).

2026-10-26 · Milestone 23: does BOHB's model (a TPE density ratio over R2 features) beat "never cut on R2" (f3)? (planned before running)

• Why: milestone 22's "Next" and paper section 6 item 3. BOHB (Falkner et al. 2018) replaces Hyperband's random sampling with a kernel-density ratio l(x)/g(x) (TPE, Bergstra et al. 2011) fitted on the observations of a rung; with pools of about 50 and at most about 40 routed points the model is cheap and stdlib-feasible. Same harness as milestone 22 (20 designs, two clocks, 40 cells, cost model, budgets 15, 25, 40 routed-point equivalents, m = 5 random pilots routed through R3+R4, screening share 0.4 at R2), 400 paired seeds (the KDE is far cheaper than the exact GP). After each routed point: good set = best ceil(0.25 n) routed points (at least 2) by routed ADP, bad = the rest; Gaussian product-kernel densities on standardised R2 features with Scott bandwidth n^(-1/(d+4)) floored at 0.3 (fixed in advance, not tuned); route the unrouted screened candidate maximising l/g. Arms: tpe1 (log R2 ADP), tpe2 (log R2 area, log R2 period), tpe2r (tpe2 but a random candidate with probability 1/3 per pick, as BOHB does). Script experiments/mf_tpe/tpe.py, stdlib only, no flow run.
• Predictions (fixed now): (1) No TPE arm beats f3 on mean regret at any budget (same R2 features whose mis-ranking milestones 18 to 22 traced). (2) The best TPE arm is worse than the best GP arm of milestone 22 (0.74 at 40) by at least 0.1 at 40: a density ratio from at most about 10 routed points is a noisier model than a GP. (3) tpe2r beats tpe2 on barrel64 at 40 (the random fraction escapes the mis-ranked region). (4) tpe1 and tpe2 differ by under 0.3 points at every budget. Each is refuted by the opposite.
• Limits known in advance: this is BOHB's model inside a single-pool search, not the full bracket schedule; quantile, bandwidth floor and random fraction fixed and untuned; R2 features only; same 20 designs, one tool version and corner.

### Outcome (experiments/mf_tpe/: tpe.py about 20 min, results.txt, summary.json; no flow run)

• Deviation from the plan: 100 paired seeds, not 400. The 400-seed run was still going after 25 minutes (the KDE is O(n^2) per pick over every unrouted candidate) and was killed with no output. Differences under about 0.15 points are not resolved; f3 reads 3.03 / 1.49 / 0.45, the same as milestone 22's 100 seeds, so the columns pair with that table.
• Mean regret % over 40 cells at 15 / 25 / 40 equivalents: f3 3.03 / 1.49 / 0.45; random 3.56 / 1.77 / 0.36; tpe1 4.59 / 2.87 / 1.67; tpe2 4.33 / 2.49 / 1.35; tpe2r 4.32 / 2.34 / 1.11.
• (1) held. No TPE arm beats f3 at any budget. tpe1 loses to f3 on 25, 25 and 24 of 40 cells (wins 11, 7, 3; sign test p 0.029, 0.002, below 0.001; cells not independent). Random R4 beats every TPE arm at 40.
• (2) held. The best TPE arm at 40 (tpe2r, 1.11) is 0.37 worse than the best GP arm of milestone 22 (0.74), more than the 0.1 predicted. At 15 and 25 the best TPE arms (4.32, 2.34) are also behind the best GP arms (3.77, 1.87).
• (3) held. tpe2r reaches 7.03% on barrel64 at 40 against 12.22 for tpe2 (f3 0.0, GP arms 0.13): the random fraction escapes part of the mis-ranked region but not all of it.
• (4) refuted. tpe1 and tpe2 differ by 0.26, 0.38 and 0.32 points at 15, 25 and 40; the two-feature density does better at every budget, as the GP arms did at 15 in milestone 22 (and unlike ridge in milestone 20).
• Reading: BOHB's model, in this single-pool form, is the weakest of the three model-based baselines (ridge with exploration 1.12 at 40, GP 0.74, TPE 1.11 at best) and does not beat never cutting on R2 or random routing at any budget. A density ratio from at most about 10 routed points, on features that mis-rank barrel64, concentrates routing on the wrong region (tpe1 stays at 18.5% there at 40). Together with milestones 20 to 22 this closes the model-based baselines of paper section 6 item 3 for pools of about 50 and R2 features. Full BOHB (brackets, per-rung models), larger pools and R3-fed models are not covered.
• Limits: 100 seeds; gamma 0.25, bandwidth floor 0.3 and random fraction 1/3 fixed and untuned; R2 features only; single-pool selection, not the bracket schedule; same 20 designs, one tool version and one corner; the sign test treats cells as independent.
• Next: the paper's remaining gaps are larger designs and a second corner, which need OpenROAD and Yosys (absent here).

2026-10-26 · Milestone 22: does a Gaussian-process BO baseline (expected improvement) beat "never cut on R2" (f3)? (planned before running)

• Why: milestones 20 and 21 closed off the ridge surrogate; paper section 6 item 3 asks for a BO baseline with a real GP. Pools are small (about 50) and routed points few (at most about 40), so an exact GP with a Cholesky solve in the stdlib is cheap. Same harness as milestone 21 (20 designs, two clocks, 40 cells, cost model, 400 paired seeds, budgets 15, 25, 40 routed-point equivalents, m = 5 random pilots routed through R3+R4, screening share 0.4 at R2). The GP models log routed ADP over standardised R2 features (gp1: log R2 ADP; gp2: log R2 area and log R2 period), RBF kernel, lengthscale 1.0, signal variance 1.0, noise variance 0.05 on the standardised target, all fixed in advance and not tuned. Acquisition: expected improvement (ei) or lower confidence bound with k = 2 (lcb); the next routed point maximises the acquisition over the unrouted screened candidates, refitting after each (experiments/mf_gp/gp.py, stdlib only, no flow run).
• Predictions (fixed now): (1) No GP arm beats f3 on mean regret at any budget: the features are the same R2 columns whose mis-ranking milestones 18 to 21 traced. (2) The best GP arm improves on the best milestone-21 ridge arm (mf1eps, 1.12 at 40) by under 0.3 points at 40: a better uncertainty model does not create information the feature lacks. (3) barrel64 mean regret for every GP arm stays above 3% at 40 (f3 0.0). (4) At 15 equivalents a one-feature GP (gp1) beats the two-feature one (gp2), because with five pilots the extra dimension is noise (milestone 20 saw this for ridge). Each is refuted by the opposite.
• Limits known in advance: hyperparameters fixed and untuned (tuning on these 20 designs would be in-sample); R2 features only; the GP is exact but the lengthscale is one value for both features; same 20 designs, one tool version and corner.

### Outcome (experiments/mf_gp/: gp.py about 940 s, results.txt, summary.json; no flow run)

• Deviation from the plan: 100 paired seeds, not 400. The first run with 400 seeds hit the 10-minute background limit and was killed with no output; the exact GP is several times slower than the ridge arms. Fewer seeds widen the noise of every column (f3 reads 3.03 / 1.49 / 0.45 here against 3.05 / 1.35 / 0.44 in milestone 21), so differences under about 0.15 points are not resolved, and comparisons with milestone 21's 400-seed numbers are indicative only.
• Mean regret % over 40 cells at 15 / 25 / 40 equivalents: f3 3.03 / 1.49 / 0.45; random 3.56 / 1.77 / 0.36; gp1ei 4.11 / 2.24 / 0.80; gp1lcb 4.40 / 2.52 / 0.78; gp2ei 3.77 / 1.87 / 0.75; gp2lcb 3.77 / 1.89 / 0.74.
• (1) held. No GP arm beats f3 at any budget (best GP 3.77, 1.87, 0.74 against 3.03, 1.49, 0.45). gp1ei loses to f3 on 24, 23 and 23 of 40 cells at 15, 25, 40 (wins 12, 8, 3; sign test p 0.065, 0.011, below 0.001; cells not independent). Random R4 also beats every GP arm at 40 (0.36).
• (2) refuted. The best GP arm (0.74 at 40) is 0.38 points better than milestone 21's best ridge arm (1.12 at 40, from a different seed count), more than the 0.3 allowed. An uncertainty model that is actually a posterior does help the surrogate; it still does not reach f3 or random.
• (3) refuted. On barrel64 at 40 the two-feature GP arms reach 0.13% (f3 0.00, random 0.80, greedy ridge 13.6 in milestone 20). A GP escapes the mis-ranked region that the greedy and lcb ridge arms did not, because the pilot points' residuals reshape the whole surface instead of one linear slope. At 15 and 25 barrel64 is still 10.7% and 4.3%, about f3's.
• (4) refuted. At 15 equivalents gp2 (3.77) beats gp1 (4.11 ei, 4.40 lcb): with a nonparametric model the second feature (R2 period, the one that mis-ranks) is worth having, unlike the ridge case of milestone 20.
• Reading: a real GP-EI baseline closes the barrel64 failure at the largest budget but spends the screening share and the pilot on a model that, on features R2 supplies, still ranks worse than routing a random subset or cutting on R3. The negative headline for paper section 6 item 3 stands, now against a proper BO baseline and not only ridge. It covers this pool size (about 50), these R2 features and fixed untuned hyperparameters; larger pools, R3 features for routed points, and tuned kernels remain open, and tuning on these 20 designs would be in-sample.
• Limits: 100 seeds; fixed lengthscale, signal and noise (no marginal-likelihood fit); one kernel; R2 features only; same 20 designs, one tool version and one corner; the sign test treats cells as independent.
• Next: wall-clock BOHB proper (KDE-based model inside Hyperband brackets) needs the same cached tables and is stdlib-feasible; larger designs and a second corner need OpenROAD.

2026-10-26 · Paper and artefact sync after milestones 17 to 21

• No experiment run. PAPER.md section 5 now reports milestone 21 (exploration does not rescue the learned surrogate), and reproduce.sh lists the five scripts of milestones 17 to 21 that it had left out, so one command re-derives every cited table. Did not re-run the 150 s and 350 s scripts here; they are the ones that produced the committed tables.
• Open and unchanged: larger designs and a second corner need OpenROAD and Yosys, which this container lacks; BOHB with a real GP needs a package the stdlib harness avoids.

2026-10-26 · Milestone 21: does an exploration term rescue the learned surrogate of milestone 20? (post hoc: script run once before this entry was written)

• Why: milestone 20's "Next". Same harness (pools, cost model, 400 paired seeds, m = 5, screening share 0.4, ridge 1.0), with the greedy pick replaced by a lower confidence bound (predicted log ADP minus k times a predictive sd, k = 2, sd = residual sd floored at 0.02 times sqrt(1 + 1/n + ridge leverage)) or by epsilon-greedy (random point with probability 0.3). k and epsilon were fixed in advance and not tuned. Features: R2 ADP (mf1) or log R2 area and period (mf2). R3 features were not tried: only points already routed through R3 have them, so they cannot rank unrouted candidates. Runs no flow (experiments/mf_explore/explore.py, about 350 s).
• Disclosure: the script ran once before I wrote this entry, so what follows reports the outcome, not pre-registered predictions. The hypothesis it tests is the one milestone 20 left open: exploration lets the surrogate escape barrel64's mis-ranked region and beat f3.
• Outcome (40 cells, mean regret % at 15 / 25 / 40 equivalents): f3 3.05 / 1.35 / 0.44; random 3.40 / 1.68 / 0.38; greedy mf1 4.58 / 2.95 / 1.43; mf1lcb 4.47 / 2.80 / 1.27; mf1eps 4.41 / 2.62 / 1.12; mf2lcb 4.61 / 2.65 / 1.12; mf2eps 4.61 / 2.73 / 1.26. barrel64 at 40: greedy 13.6, mf1lcb 10.4, mf1eps 7.2, mf2lcb 7.3 (f3 0.0, random 1.1). mf1lcb beats f3 on 11, 5 and 3 of 40 cells (sign test p 0.03 or lower, cells not independent).
• Reading: exploration helps, the most on barrel64 (about halving its regret at 40), and every exploring variant improves on greedy at every budget, but none beats f3 or random at any budget. The surrogate's remaining deficit is not only lack of exploration: with at most about 10 routed points and a feature that mis-ranks, the model spends budget that random routing or "do not cut on R2" spends better. A surrogate in this smallest form is closed off as a baseline for paper section 6 item 3, as a negative result.
• Limits: single k and epsilon, untuned; sd is a ridge-leverage proxy, not a GP posterior; R2-only features; same 20 designs, one tool version and corner; budgets in routed-point multiples; sign test treats cells as independent; post hoc as disclosed above.
• Next: wall-clock BOHB with a real GP (needs a package the stdlib-only harness avoids), or the repairability feature of milestone 18 in a session with OpenROAD.

2026-10-26 · Milestone 20: does a learned multi-fidelity surrogate beat "never cut on R2" (f3) at equal budget? (planned before running)

• Why: milestone 18 found the missing R2 information is the post-repair period, and paper section 6 item 3 asks for a model-based baseline. Pools of 50 are too small for a GP, but a two-parameter regression can be fitted from a handful of routed points, which is the multi-fidelity-surrogate idea in its smallest form. Arm mf2: screen n0 random points at R2 (cost c2 each, n0 = min(pool, 0.4 B / c2)); route m = 5 of them through R3 and R4 (extra cost c3 + c4 each); fit ridge regression of log routed ADP on log R2 area and log R2 period; then repeatedly route the point with the lowest prediction, refitting after each, until the budget is spent; pick the best routed. Arm mf1: same with the single feature log R2 ADP. Compared with random R4, fixed eta = 1.5 and f3 on the 40 cells (20 designs, two clocks), budgets 15, 25, 40 routed-point equivalents, 400 paired seeds, regret and cost model of milestones 16 and 17 (experiments/mf_surrogate/surrogate.py, stdlib only, no flow run).
• Predictions (fixed now): (1) mf2 beats mf1 on mean regret at 25 and 40, because it can reweight the period that R2 gets wrong. (2) mf2 beats f3 at 40 by at least 0.1 points, but not at 15, where screening eats the budget. (3) mf2 has a smaller worst-cell regret than f3 at 25. (4) On barrel64 mf2 stays above 5% mean regret at 15: with five pilots a two-feature fit cannot learn a repair effect that R2 does not carry. Each is refuted by the opposite.
• Limits known in advance: m = 5, the 0.4 screening share and the ridge strength are fixed in advance and not tuned; greedy exploitation with no uncertainty term, so it is not BO; the same 20 designs as milestones 16 to 18.

### Outcome (experiments/mf_surrogate/: surrogate.py about 150 s, results.txt, summary.json; no flow run)

• (1) refuted. mf2 (log R2 area and log R2 period) is worse than mf1 (log R2 ADP) at every budget: 4.80 against 4.58 at 15, 3.08 against 2.95 at 25, 1.71 against 1.43 at 40. Letting the model reweight area and period did not help; with five pilots it fits noise as readily as signal.
• (2) refuted. Neither beats f3 at any budget. Mean regret over 40 cells: f3 3.05, 1.35, 0.44 and mf2 4.80, 3.08, 1.71 at 15, 25, 40. Both lose to plain random R4 at every budget (3.40, 1.68, 0.38). Paired per cell, mf2 beats f3 on 8, 4 and 3 of 40 cells (sign test p about 0.001 or lower, with cells not independent: two clocks per design).
• (3) refuted. Worst-cell regret at 25 is 21.5% (barrel64 tight) for mf2 against 10.7% for f3.
• (4) held. barrel64 mean regret for mf2 is 21.1% at 15 and still 19.2% at 40, where f3 and random reach 0.0 and 1.1. The surrogate converges on the wrong points and, being greedy, stops exploring them: a regression on R2 features cannot learn the repair effect that R2 does not carry (milestone 18), and routing the predicted best rather than a spread leaves no chance to be corrected.
• Reading: a learned surrogate on R2 features is a worse use of budget than either "route random points" or "do not cut on R2" on these pools; it inherits R2's mis-ranking and amplifies it by committing to its predictions. This is a negative result for the model-based baseline in paper section 6 item 3, for this smallest-model form only. It does not say a GP with an uncertainty term, or a surrogate fed R3 features, would fail.
• Limits: greedy exploitation with no uncertainty or exploration term, so not BO; one pilot size, screening share and ridge strength, none tuned (tuning on these 20 designs would be in-sample); features from R2 only; same 20 designs, one tool version and one corner; budgets in routed-point multiples; the sign test treats the 40 cells as independent, which they are not.
• Next: the same harness with an exploration term (surrogate mean minus k times the residual sd) and R3 features for the points that reach R3; then wall-clock BOHB. Both stay on the cached tables; the repairability feature of milestone 18 still needs a session with OpenROAD.

2026-10-26 · Milestone 19: does a score learned on other designs beat the hand-made R2 and R3 scores? (held out by design)

• Why: milestone 18's reading was that R2 needs a feature that sees repairability. Before a flow run is possible (this session has no yosys or OpenROAD), test whether the columns already in the tables, combined by a model fitted on other designs, carry it. Ridge regression (lambda 1, fixed in advance) of the centred log routed area-delay product on centred log features, fitted on 19 designs (both clocks) and used to pick on the held-out design's two cells (experiments/learned_score/learned.py, seconds, no flow run). Feature sets: R2 (area, period), R2 + R1 (adds Yosys-ABC cell count and depth), R3 (area, period), R2 + R3.
• Disclosure: I ran the script once before writing this entry, so the predictions below are post hoc, not pre-registered. What I wrote down after seeing the output only restates it; the claim that matters is the held-out column.
• Outcome (results.txt, summary.json; 40 cells): mean / max regret, held-out: hand ADP at R2 7.69 / 82.7; ridge R2 7.59 / 82.7 (one cell better by over a point, none worse); ridge R2 + R1 6.99 / 86.8 (8 cells better, 6 worse, 11 above 10%); hand ADP at R3 4.77 / 18.2; ridge R3 4.77 / 18.2 (identical picks); ridge R2 + R3 5.01 / 18.2. In-sample (not held out) R2 + R1 reaches only 6.39 / 86.8.
• Reading: no learned combination of R1 to R3 columns removes barrel64's 82.7% regret even in-sample; the R2 ridge fits its period weight at 0.42 (a hand ADP uses 1) and still picks the same barrel64 point. Learned weights give no held-out gain over the hand-made scores, and the only thing that fixes the worst cell remains moving the period one rung up to R3. This closes off "re-weight the existing cheap columns" as the route to a better R2 score; a new feature (post-repair slack, critical-path fanout) needs a flow run.
• Limits: 20 designs and 40 non-independent cells; one ridge penalty, not tuned; linear in logs only, no trees or interactions; four feature sets compared without correction; one tool version and corner; full-pool picks, not budgeted searches; post hoc as disclosed above.
• Next: in a session with yosys and OpenROAD, add repairability features (critical-path fanout, slack histogram) at R2 and test them with the same held-out protocol, or disable repair_timing on barrel64 to test milestone 18's explanation; then wall-clock BOHB/BO (paper section 6 item 3).

2026-10-26 · Milestone 18: is it R2's area or R2's period that mis-ranks, and where is the room? (diagnostic on the committed tables)

• Why: milestone 17's "Next" (why R2 mis-ranks barrel64). Before writing this entry I looked at barrel64 and alu32 only (rung_bias-style tau of each factor of the area-delay product, nonarith table): barrel64 R2 area tau-b 0.98 against routed area, but R2 period tau-b 0.12 (tight) and 0.08 (relaxed). The R2 pick has a no-wire period of 3.35 ns and routes to 3.13; the routed best has R2 period 6.01 and routes to 2.24, because repair_timing fixes a slow netlist that R2 scored as slow. That is a hypothesis built from two designs; this step tests it on all 40 cells (experiments/r2_components/components.py, seconds, no flow run). Scores compared: R2 ADP (baseline), R2 area only, R2 area x R3 period, R3 ADP, R3 area only, and an oracle (R2 area x routed period).
• Prediction made after the barrel64 read, so only partly a test: (1) mean tau-b of R2 area against routed area is above 0.8 and of R2 period below 0.5. (2) Picking on R2 area alone is worse than the R2 ADP baseline (the period matters for the objective). (3) R2 area x R3 period cuts the baseline's worst-cell regret (82.7%) below 20%. (4) The oracle (R2 area, routed period) gets mean regret below 2%, i.e. the missing information is the period, not the area.

### Outcome (experiments/r2_components/: components.py, results.txt, summary.json; no flow run, 40 cells, full pools of about 50 points)

• (1) half held. Mean tau-b of R2 period is 0.38 tight and 0.49 relaxed (below 0.5, as predicted) but R2 area is 0.72 tight and 0.91 relaxed, so area is above 0.8 only at the relaxed clock. At the tight clock area is not reliable either.
• (2) held, strongly. R2 area only: mean regret 30.5% (max 349.8%, 19 cells above 10%) against 7.69% (max 82.7%, 12 cells) for R2 ADP. Routed area spreads 43% and period 52% on average, so neither factor can be dropped.
• (3) held. R2 area x R3 period: mean 4.79%, max 18.2%, 10 cells above 10%; R3 ADP is the same on worst case (4.77%, 18.2%). Moving the period one rung up (placement, still before routing) removes the catastrophic cells. R3 period tau-b is 0.46 tight and 0.67 relaxed against 0.38 and 0.49 at R2.
• (4) held. The oracle (R2 area, routed period) has mean regret 1.15%, median 0, 2 cells above 10% (max 16.7%): the missing information at R2 is the post-repair period, not the area.
• Reading: R2 mis-ranks because its period is the no-wire, pre-repair period, and the routed flow's timing repair reorders candidates by how much repair can recover; the area factor is largely inherited (barrel64 tau 0.98). A second pilot statistic or a mapping-level feature has to predict repairability of the period; R3's period already carries part of it, and the cost of R3 is the question the earlier milestones priced (cuts after R2 floor, cuts after R3 do not).
• Limits: full-pool picks, not budgeted searches; no flow was run and the explanation (timing repair recovers slow netlists) is read off the numbers for barrel64, not isolated by an experiment that disables repair_timing; the barrel64 read preceded the predictions; 40 cells are 20 designs times two clocks, not independent; one tool version and corner; no test of significance.
• Next: a repairability feature at R2 (e.g. critical-path fanout and slack histogram, which need the OpenROAD netlist and so a flow run in a session with yosys/OpenROAD), or an experiment that disables repair_timing on barrel64 to test the explanation directly; then wall-clock BOHB/BO (paper section 6 item 3).

2026-10-26 · Milestone 17: does a bigger pilot or a held-out threshold make the R2-to-R3 gate beat "never cut on R2"? (planned before running)

• Why: milestone 16's "Next". Its best gate (tau(R2,R3), theta 0.7, m = 5) beat f3 by only 0.09 points at 25 and 0.10 at 40, inside noise, with theta and m fixed in advance but only three thetas tried on the same 20 designs. This step sweeps the pilot size m in {3, 5, 8, 10} and theta in {0.3, 0.5, 0.7, 0.9} for the R3 statistic only, and chooses theta leave-one-design-out (lowest mean regret over the other 19 designs, both clocks, per budget and m), scoring on the held-out design. Budgets 15, 25, 40 routed-point equivalents; cost model, pools, 400 paired seeds and regret as milestone 16. Runs no flow (experiments/pilot_sweep/sweep.py).
• Predictions: (1) Pilot-tau sd falls with m (about 0.24 at 5, below 0.17 at 10) but the cell-level AUC for "R2 pick regret > 10%" rises by less than 0.05 from m = 5 to 10. (2) The held-out-theta gate (any m) does not beat fixed f3 by 0.1 points at any budget; at 25 it is within 0.15 of f3 either way. (3) The in-sample best (m, theta) at each budget beats f3 at 25 and 40, but its edge shrinks by at least half once theta is held out. (4) At 15 equivalents m = 10 is worse than m = 3 (the pilot eats the budget). Each is refuted by the opposite.
• Limits known in advance: the same 20 designs as milestone 16; 4 x 4 grid compared with no correction; held-out over designs not families.

### Outcome (experiments/pilot_sweep/: sweep.py about 90 s, results.txt, summary.json; no flow run)

• (1) held. Pilot tau(R2,R3) within-cell sd is 0.40, 0.24, 0.16 and 0.14 at m = 3, 5, 8, 10, but the cell-level AUC for "R2 pick regret > 10%" does not move: 0.74, 0.72, 0.74, 0.73. A bigger pilot reduces noise in a single run without making the statistic more informative about the cell; the limit is what tau(R2,R3) says, not how well it is measured.
• (2) half held. The held-out-theta gate never beats f3 by 0.1 (best: m = 5 at 15 equivalents, 3.06 against 3.05), but it is not "within 0.15" either: at 25 it is worse than f3 (1.35) by 0.50, 0.39, 0.27 and 0.19 for m = 3, 5, 8, 10, and at 40 by 0.57, 0.38, 0.26 and 0.16 (f3 0.44; random 0.38 beats every held-out gate).
• (3) held, more strongly than predicted. In-sample the best (m, theta) beats f3 at 25 (1.28 against 1.35) and at 40 (0.22 against 0.44, m = 10), and once theta is chosen on the other 19 designs the edge is gone entirely (0.60 at 40, m = 10). In-sample thresholds above 0.5 look good because barrel64 and alu32 are in the sample; the leave-one-out fold that holds one of them out picks a threshold from designs that lack that failure.
• (4) held in-sample, tied held-out. At 15 the best in-sample gate is 3.04 at m = 3 (theta 0.9) and 3.21 at m = 10; held-out both are 3.29.
• Reading: milestone 16's R3 gate at theta 0.7 was a small in-sample gain and does not survive a held-out threshold, whatever the pilot size. With 20 designs, "do not cut on R2 rank" (f3) remains the recommendation, and a pilot-based gate is not worth building on this evidence. The remaining room (the oracle gate, 0.4 to 0.6 points in milestone 16) needs a statistic that sees what tau(R2,R3) does not: why R2 mis-ranks barrel64.
• Limits: same 20 designs and one tool version as milestone 16; 16 gate settings compared without correction (the held-out column is the honest one); held-out over designs, so the two clocks of one design share a fold; one corner; budgets in routed-point multiples.
• Next: look at why R2 mis-ranks barrel64 (mapping-level features available at R2, e.g. fanout or mux depth) as a second pilot statistic, or move to wall-clock BOHB/BO comparisons (paper section 6 item 3).

2026-10-26 · Milestone 16: can a cheap pilot statistic tell when cutting on R2 rank is safe? (planned before running)

• Why: milestones 13 and 15 end on the same recommendation: do not cut on R2 rank unless a pilot says R2 ranks well. This step builds that gate and prices it. Pilot = m = 5 random points routed through R4 (cost charged from the budget; they stay in the candidate set). Statistic = Kendall tau-b of R2 against R4 on the pilot (also R2 against R3, as a variant). Rule: tau >= theta then successive halving with eta = 1.5, else "f3" (no cut after R2). theta in {0.3, 0.5, 0.7} fixed in advance, not tuned. Replay on all 20 designs, both clocks (40 cells), budgets in routed-point equivalents (10, 15, 25, 40 times the mean full-flow cost of the table) so the three tables share one axis, 400 paired seeds, same cost model and regret as milestones 13 and 15. Runs no flow (experiments/pilot_gate/gate.py).
• Diagnostic read before writing this entry, from the committed per-design tables only (full-pool R2 vs R4 tau-b and R2-pick regret): the full-pool tau does not cleanly separate the bad cells. barrel64 tight has tau 0.49 and regret 32.7%, but adder_op16 tight has tau 0.77 and regret 18.2%, and mult24 tight has tau 0.73 and regret 0.4%. So I expect a weak gate.
• Predictions: (1) With m = 5 the pilot tau has a sampling sd above 0.3, and its AUC for the label "R2 pick regret > 10% on the full pool" is below 0.75 (40 cells). (2) The best gated arm beats the worse of fixed eta = 1.5 and f3 at every budget but does not beat the better one, so the gate buys robustness, not a lower mean. (3) At the 10-point budget the pilot (5 points) costs more than the gate saves: fixed f3 beats every gated arm there. (4) The oracle gate (picks the better of 1.5 and f3 per cell from the full pool, no pilot cost) beats both fixed arms by at least 0.3 points at some budget, so a perfect statistic would be worth building. Each is refuted by the opposite result.
• Limits known in advance: three thresholds on 40 cells that include the designs the diagnostic above was read from; one pilot size; budgets are fixed multiples, not the wall-clock budgets of milestones 13 and 15.

### Outcome (experiments/pilot_gate/: gate.py about 50 s, results.txt, summary.json; no flow run)

• (1) refuted. Pilot tau(R2,R4) with m = 5 separates the 12 cells whose full-pool R2 pick regret exceeds 10% from the other 28 with AUC 0.85 on cell-mean tau (mean 0.45 against 0.69), and its mean within-cell sd is 0.29, just under my 0.3. The cheaper pilot tau(R2,R3) has AUC 0.74 (0.59 against 0.78), sd 0.24. My diagnostic on the full-pool tau looked weaker than this; averaging the pilot over seeds is why the cell means separate better than single cells.
• (2) refuted for the R2-to-R3 variants, held for the R2-to-R4 ones. Mean regret over 40 cells at 25 routed-point equivalents: random 1.74, fixed eta = 1.5 2.12, fixed f3 1.40, gate on tau(R2,R4) at theta 0.5 1.73, gate on tau(R2,R3) at theta 0.5 1.40 and at 0.7 1.31. At 40: random 0.39, f3 0.44, gate on R3 at 0.7 0.34. So the R3 gate at 0.7 beats f3 by 0.09 and 0.10 points, which is inside what 400 seeds on 40 cells would call noise (no test run), and the R4 gates are worse than f3 at every budget. The gate never beats f3 by a margin I would claim.
• (3) refuted by 0.02 points. At 10, f3 is 4.76 and the R3 gates are 4.74; the R4 gates (4.89, 4.90) lose to f3 as predicted. The pilot's five routed points cost half the budget, yet they also count as candidates, so the cost is smaller than I assumed.
• (4) held. An oracle that picks the better of eta = 1.5 and f3 per cell (no pilot cost) gets 0.98 against f3's 1.40 at 25, 2.54 against 3.13 at 15 and 0.04 against 0.44 at 40. The room for a perfect statistic is 0.4 to 0.6 points; the pilot gates take back 0.00 to 0.09 of it at best. The cells that carry the oracle's gain are barrel64 (eta = 1.5 at 26.9, f3 at 3.8 to 4.3), barrel16 and alu32, i.e. the same designs as in milestones 13 and 15.
• Also: f3 beats random R4 at 15 and 25 equivalents (3.13 against 3.48; 1.40 against 1.74) and loses at 40 (0.44 against 0.39), and fixed eta = 1.5 loses to random at 25 and 40 on the 40-cell average (2.12 against 1.74; 1.38 against 0.39), because of barrel64. That is a change from the 10-design reading of milestones 13 and 14: over 20 designs, "default eta = 1.5" is no longer the recommendation; "do not cut after R2" (f3) is.
• Reading: a five-point pilot detects an unreliable R2 at the level of a cell (AUC 0.85) but not well enough at the level of a run to beat the simple policy of never cutting on R2. The simple policy is the finding.
• Limits: I read the six gates' results before choosing which to discuss (six gates, no correction); the label threshold of 10% and the pilot size 5 were fixed before the run, but one pilot size and three thetas is all that was tried; budgets are routed-point multiples, not wall-clock; the 20 designs include those used to write the prediction; the AUC is over 40 cells that are two clocks of 20 designs, so they are not independent.
• Next: a pilot size sweep (m = 3 to 10) with the R3 statistic, and a proper held-out test of the threshold (fit theta on 19 designs, apply to the 20th); then BOHB/BO at equal wall-clock (paper section 6 item 3).

2026-10-26 · Milestone 15: does the larger-design finding hold on a non-arithmetic family? (planned before running)

• Why: milestone 14's "Next". The five larger designs are two multipliers-and-adders families (mult16/24/32, adder_op64, adder_ripple64), so the gentle-cut result (eta = 1.5 beats random R4, R2-only cuts floor) may be an arithmetic property. Run the milestone-9 protocol (same 60 pass sequences from the same seed, two clocks, four rungs, Yosys 0.33, OpenROAD 26Q2, SKY130 HD tt 25C) on five new designs with no carry chain: barrel64, barrel128 (logical shifters), popcount64, popcount128 (adder trees) and alu32 (designs/barrel_w.v, popcount_w.v, alu_w.v, experiments/nonarith/run.py, 600 runs). Yosys synth sizes before any pass: 849, 654 and 1001 cells for barrel64, popcount128 and alu32.
• Analysis planned, to run unchanged on the new table: rung_bias/analyse.py logic (tau-b R1..R3 against routed R4, regret of each rung's pick), then halving, eta_floor and signif replays on the 10 + 5 + 5 designs.
• Predictions: (1) R1 (Yosys-ABC cell count and depth) is a better predictor of routed cost for barrel and popcount than for multipliers (tau-b above 0.31, the multiplier tight-clock value), since wire load scales with cell count in regular fabrics. (2) Fixed eta = 1.5 beats random R4 at the relaxed clock on the new designs at the middle budgets, with the same sign on at least 4 of 5 designs (the milestone-13 pattern). (3) Successive halving from R2 with eta = 3 does not floor above 1% regret at the tight clock on this family (no carry-chain mis-ranking). Refuted if it floors above 1% on two or more designs.
• Stopping rule: if OpenROAD cannot be built in this session, the run stops after the designs, script and this entry, and says so below.

### Outcome (experiments/nonarith/: run.py about 35 min on 4 cores, analyse.py, sweep.py about 100 s, perdesign.py, results.txt, perdesign.txt; 600 flow runs, 96 rejected as in milestone 9)

• Cost: a routed point takes 3.9 s here against 19.4 s on the larger arithmetic designs, so the budgets for the replay (20, 40, 80, 150, 250 s, chosen from that cost so the last one routes the whole pool of 50) are a choice made after seeing the run times, not before.
• (1) refuted. Tight-clock R1 tau-b against routed cost: barrel64 0.47, barrel128 0.08, popcount64 0.01, popcount128 -0.24, alu32 -0.13 (median 0.01). Only barrel64 is above the multiplier value 0.31. R1 is a worse predictor of routed cost on this family than on multipliers, and R2 and R3 carry the ranking (R3 median tau 0.56 tight, 0.79 relaxed).
• (2) held at 80 s, not beyond. Relaxed clock, 80 s, fixed eta = 1.5 against random R4: alu32 2.00 vs 3.46, barrel128 4.13 vs 6.90, popcount64 1.17 vs 2.13, popcount128 1.08 vs 2.04, but barrel64 26.90 vs 13.02, so 4 of 5 designs have the predicted sign. At 250 s random reaches 0.0 on every design while any R2-cut arm sits at 26.9% on barrel64.
• (3) refuted. At the tight clock and 250 s, eta = 3 floors at 26.9% on barrel64 and 15.7% on alu32; eta = 1.5 and 2 floor at 26.9% on barrel64 only. The cause is visible in results.txt: R2 picks the wrong barrel64 point (regret 32.7% tight, 82.7% relaxed) and a cut after R2 never lets the optimum reach R3 or R4. Arms with no cut after R2 ("f2", "f3") reach 0.00 on all five designs at 250 s and are the best fixed arms from 150 s at both clocks (1.12 and 0.98 against random's 1.99 at 150 s tight; 1.04 and 0.82 against 2.11 relaxed).
• Reading: the milestone-9 bias floor is not an arithmetic artefact; it reappears on a different family, driven by one design in each case (barrel64 here, the 24 and 32-bit multipliers there), and a filter that skips the R2 cut removes it. Held-out choice among the arms picks "f2" or "f3" in 4 of 5 folds at most budgets, but loses to random at 80 s and over because the fold that leaves barrel64 out picks eta = 2, the same barrel64-driven choice problem as barrel16 in milestone 13. So on 10 + 5 + 5 designs, the paper's recommendation is the one milestone 13 reached: do not cut on R2 rank unless the R2-to-R3 rank correlation has been checked on a pilot.
• Limits: five designs, one corner, one tool version; the barrel64 floor is a single design and I have not looked at why R2 mis-ranks it (it may be one mapping that Yosys-ABC maps well and OpenROAD routes badly); budgets chosen after the run times were known; no significance test run on this table (five designs gives a minimum exact Wilcoxon p of 0.0625).
• Next: a pilot statistic that flags barrel64 and the 24/32-bit multipliers before any cut (R2-R3 rank agreement on the pilots, with the conformal machinery of milestones 4 and 10), tested on all 20 designs.

2026-10-25 · Milestone 14: is gentle-cut halving better than random R4 under a paired test, and does a per-family fold change the held-out choice? (planned before running)

• Why: milestone 13's "Next". Its win/loss counts were descriptive. This step tests fixed eta in {1.25, 1.5, 2} and "f3" against random R4 per design (400 paired seeds, 95% bootstrap CI of the paired difference) and across designs with an exact two-sided Wilcoxon signed-rank test on the per-design mean differences, Holm-corrected over the cells of each table and clock. It also re-does the held-out choice among the 7 arms leaving a whole family out (adder family: adder_op/adder_ripple; mult family: mult8/16/24/32) instead of one design. experiments/signif/test.py, no flow run.
• Statistical limit known in advance: with 10 designs the smallest exact two-sided p is 0.002, and with 5 designs it is 0.0625, so no cell of the larger table can reach p < 0.05 by this test, and Holm over 32 cells needs p below 0.0016 for the first rejection, which 10 designs cannot give. I expect to be able to say "consistent sign across designs" but not "Holm-significant" for any cell.
• Predictions: (1) eta = 1.5 vs random, small designs, tight clock: raw p < 0.05 at 30 and 45 s (7/1 wins in milestone 13). (2) Small designs, relaxed clock: eta = 1.5 raw p < 0.05 at 45 s only; at 30 s the sign is mixed. (3) Zero Holm-significant cells in either table. (4) Larger designs: eta = 1.5 and f3 have the same sign on all five designs at relaxed 400 and 600 s. (5) The per-family fold chooses a harder cut (eta 2 or 3) for the held-out mult family at the relaxed clock on the larger designs, so the held-out mean there is worse than fixed eta = 1.5.

### Outcome (experiments/signif/: test.py about 75 s, results.txt, summary.json; no flow run)

• (1) held. Small designs, tight clock, eta = 1.5 against random R4: mean difference -0.57, -0.57 and -0.51 points at 20, 30, 45 s; raw exact Wilcoxon p = 0.012, 0.008, 0.004; better/worse designs (seed CI excludes 0) 5/0, 7/0, 7/0.
• (2) mostly held. Relaxed clock, eta = 1.5: p = 0.012 at 45 s (8/0), but 30 s is not mixed as I predicted: 7 better, 1 worse, mean -0.16, raw p = 0.13. "f3" does not beat random on the small designs at the relaxed clock beyond 10 s (mean +0.39 to +0.77 points at 20 to 45 s).
• (3) held, and the test cannot do otherwise. The smallest Holm-adjusted p anywhere is 0.0625 (0.062 at the tight 45 s cell, 0.086 at 30 s). With 10 designs and 16 cells per table-clock, one Holm-significant cell would need raw p below 0.003, close to the floor of 0.002. So the claim the data supports is "consistent sign across designs, raw p < 0.05 in 4 cells, none surviving correction".
• (4) mostly held. Larger designs, relaxed clock, 400 and 600 s: eta = 1.5 and f3 are negative on four designs and exactly 0.0 on adder_ripple64, where both random and the arms reach the optimum, so the sign is the same wherever it is non-zero. The test cannot show it: five designs give a minimum p of 0.0625, and the 4/0 cells have p = 0.125 (three zeros or ties count as dropped).
• (5) held. Per-family fold, larger designs, relaxed clock: the held-out mult family gets eta = 3 at 100 and 200 s and eta = 2 at 400 s, and the adders get "f3" until 400 s; the held-out mean is 5.31 at 200 s and 3.01 at 400 s against random's 4.85 and 2.03 and against 2.53 and 0.40 for fixed eta = 1.5. At 600 s and over the folds choose 1.5 and 1.1 and score 0.00. On the small designs the family fold picks eta = 2 for barrel16 again, so the held-out gap of milestone 13 is a barrel16 property, not a family-leakage effect.
• Reading: gentle-cut halving beats random R4 with the same sign on nearly every small design at the tight clock, and the evidence does not clear a multiple-comparison bar with 10 designs. The choice rule is the weak part: choosing eta from other designs, now with a stricter fold, still loses to a fixed 1.5 wherever one design (barrel16) or one family (mults) prefers a harder cut. A paper claim should be "eta = 1.5 as a default" with this stated limit, not "eta is learned".
• Limits: 10 and 5 designs, three larger ones one family; the Wilcoxon test is over designs, the bootstrap is over seeds within a design; 400 seeds share the pool of 50 to 60 points; no new flow runs.
• Next: a design-count fix only more flow runs can give (more designs, a second corner, a non-arithmetic family on the larger scale); until then the paper should report effect sizes and signs, not significance.

2026-10-25 · Milestone 13: does a gentler cut than eta = 1.5, or filtering on R3 only, remove the halving floor? (experiments/eta_floor/)

• Why: milestone 12 chose eta = 1.5 in nearly every fold, the edge of its grid, and could not separate the cut from the ranking quality. This step extends the grid to {1.1, 1.25, 1.5, 2, 3} and adds two arms that do not cut after R2 and keep 1/2 or 1/3 after R3 ("f2", "f3"). Everything else is milestone 12's (cost model, pools, 400 paired seeds, leave-one-design-out choice, sweep.py copied and extended, about 30 s, no flow run).
• Disclosure: the predictions were not written before the run in this entry. The only plan on record is milestone 12's "Next", so read the outcome as exploratory, with 7 arms by 4 tables-clocks by 4 to 5 budgets compared and no multiplicity correction.

### Outcome

• The relaxed-clock loss in the small designs is a property of the cut size. Fixed eta = 1.5 gives 1.30 against random's 1.45 at 30 s and 0.24 against 0.55 at 45 s; eta = 1.25 gives 1.21 at 30 s and 4.90 against 5.69 at 10 s. Milestone 12 saw eta = 2 lose here (1.89, 1.27). Tight clock: eta = 1.5 gives 1.49 against 2.06 at 30 s and 0.42 against 0.94 at 45 s. In-sample fixed values, not held-out.
• Held-out choice is not what delivers it. The leave-one-design-out choice picks 1.25 or 1.5 in 9 of 10 folds but picks 2 for barrel16, where that is a bad choice, so the held-out mean is worse than fixed eta = 1.25 or 1.5 (relaxed 30 s: 2.17 against 1.21 to 1.30). One design drives that gap; barrel16 was also the design with the worst losses in milestones 3 and 11.
• Larger designs: the floor is removed by a gentler cut. Relaxed clock at 600 s, eta = 1.5 gives 0.00 and eta = 1.1 or 1.25 give 0.46 and 0.17 against random's 0.83, while eta = 3 stays at 5.03 and eta = 2 at 2.99. At 900 s eta = 1.1, 1.25 and 1.5 all reach 0.00 against random's 0.18. Tight clock, 900 s: 0.00 for 1.1 and 1.25.
• Filtering on R3 only does about as well as a gentle cut. f3 is the best fixed arm on the larger designs at the relaxed clock for 100 to 400 s (4.27, 1.71, 0.21 against 5.94, 2.53, 0.40 for eta = 1.5), and f2 is close to eta = 1.5 elsewhere. So most of the benefit comes from not discarding by R2 rank, and R3 is informative enough to cut on. At the tight clock on the larger designs eta = 3 and 2 stay best from 100 to 200 s (1.34, 0.33 against 2.00 and 0.83 for 1.5), so there a harder cut wins.
• Limits: 5 larger designs of which three are one family; in-sample fixed-eta numbers are selected after seeing the grid; the held-out column covers selection among 7 arms using 4 or 9 training designs; "f3" at 600 s and over keeps most of the pool through R3, so it approaches routing the survivors of an R3 sort; pool sizes of 50 to 60 cap how small a cut can matter. No new flow runs.
• Next: a paired significance test of fixed eta = 1.5 against random per design, a per-design-family fold (so the three-multiplier family leaves together), and the second corner.

2026-10-25 · Milestone 12: is eta = 2 for halving from R2 a real gain once eta is chosen on other designs? (planned before running)

• Why: milestone 11 found, after trying it as one of two variants, that SH from R2 with eta = 2 beat random R4 on 4 to 7 of 10 small designs at the tight clock and had the lowest floor on the larger designs. Five strategies by two tables by two clocks by four or five budgets was many comparisons, and eta = 2 was picked after seeing the numbers. This step tests it out of sample.
• Method (experiments/eta_sweep/sweep.py, no flow run): milestone 3 / 9 / 11 cost model, pools, 400 paired seeds, regret definition and both tables and clocks. SH from R2 with eta in {1.5, 2, 2.5, 3, 4} (kept set at each rung = floor(n / eta), at least 1; the initial pool is the largest that fits the budget), against random R4. Leave-one-design-out: for each table, clock and budget, eta is chosen as the value with the lowest mean regret over the other designs, then scored on the held-out design. Report the mean held-out regret of the chosen eta, of fixed eta = 2, of fixed eta = 3, of the in-sample oracle best eta per design, and of random R4, with paired wins and losses of chosen-eta against random by design (95% CI over seeds).
• H12-i: at the tight clock on the small designs, the held-out chosen eta has lower mean regret than random R4 at 20, 30 and 45 s. Refuted if it is not lower at two of the three.
• H12-ii: at the relaxed clock on the small designs the chosen eta does not beat random R4 on mean regret at 30 and 45 s (milestone 11 saw 1.89 against 1.45 and 1.27 against 0.55 for fixed eta = 2). Refuted if it does.
• H12-iii: the chosen eta is 2 or smaller in most held-out folds on the larger designs at the tight clock (gentler cuts lower the bias floor). Refuted if the modal chosen eta there is 3 or 4.
• Caveats set in advance: 10 and 5 designs, so the selection folds have 9 and 4 training designs; three of the five larger designs are one family; 20 cells; the win/loss counts are descriptive.

### Outcome (experiments/eta_sweep/: sweep.py about 30 s, results.txt, summary.json; no flow run)

• H12-i held, narrowly. Tight clock, small designs, chosen eta against random R4: 3.15 against 3.33 at 20 s, 1.93 against 2.06 at 30 s, but 1.27 against 0.94 at 45 s. Two of three, as the refutation rule allowed; the margins at 20 and 30 s are 0.2 and 0.1 points, with paired wins/losses of 5/1 and 7/1 over designs. Fixed eta = 2 (0.57 at 45 s) does better than the held-out choice there, so selecting eta on other designs costs something.
• H12-ii held. Relaxed clock, small designs: chosen eta 2.15 against random 1.45 at 30 s and 1.39 against 0.55 at 45 s. Nothing here removes the relaxed-clock loss.
• H12-iii held. Larger designs, tight clock: the chosen eta is 2 or below in 16 of 25 folds (2 at 400 s; 1.5 at 600 and 900 s); at 100 s it is mostly 3 and at 200 s 2.5, so the "gentler cut" is a large-budget effect.
• Unpredicted: on the larger designs at the relaxed clock the chosen eta is 1.5 in nearly every fold and it beats random from 200 s: 2.53 against 4.85 at 200 s, 0.40 against 2.03 at 400 s, 0.00 against 0.83 at 600 s, with 4/0 wins. Fixed eta = 3 floors at 5.03 there. So the milestone 9 "bias floor" is a property of the aggressive cut, not of the R2 ranking, at least with this pool of five designs (three of one family). At 600 s and over, eta = 1.5 keeps most of the pool through R3, so it is close to filtering with R3 then routing; I have not separated that from the benefit of multi-fidelity ranking.
• Caveats: 1.5 is the edge of the grid and is chosen in nearly every small-design fold, so the optimum may lie lower and the grid, not the data, bounds the answer; with five larger designs, folds train on four; 20 cells and descriptive win/loss counts; a held-out design is scored with the same seeds as the pool it was drawn from (pool of 50 or 60 points, not fresh designs).
• Next: extend the grid below 1.5 (1.25, 1.1) and add an arm "filter on R3 only, then route", to separate the cut from ranking quality; the second corner and a non-arithmetic family still need new flow runs.

2026-10-25 · Milestone 11: can a two-arm hedge remove the bias floor of successive halving from R2? (planned before running)

• Why: milestone 9 found SH from R2 beats random search at 100 to 400 s on the larger designs but then floors (0.30% tight, 5.03% relaxed) because the R2 cut never lets the true optimum reach the routed rung; random search overtakes it from 600 s. Milestone 8's Hyperband hedged with equal brackets and lost the quarter of the budget it spent. A cheaper hedge: give SH from R2 a fraction f of the budget and spend the rest routing random points, answer = the best routed value of the two arms. Also a gentler cut (eta = 2) in place of eta = 3.
• Method (experiments/hedge/replay.py, no flow run): milestone 3 / 9 cost model, pool, seeds (400 paired) and regret definition, on both cached tables (10 small designs, budgets 10 to 45 s; 5 larger designs, budgets 100 to 900 s), both clocks. Strategies: random R4; SH from R2 (eta 3); SH from R2 with eta 2; hedge f = 0.5 and f = 0.75 (SH arm eta 3, random arm independent draw).
• Predictions on record: (1) On the larger designs at 600 s and over, hedge f = 0.75 has lower mean regret than SH from R2 alone at both clocks (it removes the floor) and is within 0.1 percentage points of random R4 at 900 s. (2) At 100 to 200 s on the larger designs, tight clock, hedge f = 0.75 keeps most of SH's head start (regret at 200 s below random's 1.85 and above SH's 0.33). (3) On the small designs the hedge does not beat random R4 at 10 to 30 s at either clock (consistent with milestones 3 and 8), and eta = 2 is no better than eta = 3 anywhere. If the hedge beats both random and SH from R2 at every budget on the larger designs, the bias floor is a fixable policy problem and the paper's H2 story becomes positive for the routed-expensive regime.

### Outcome (experiments/hedge/: replay.py about 60 s, results.txt, summary.json; no flow run)

• Prediction (1) half held. Hedge f = 0.75 has lower mean regret than SH from R2 at 600 and 900 s on the larger designs at both clocks (tight 0.23 and 0.21 against 0.30; relaxed 2.88 and 2.21 against 5.03), so the floor is partly removed. It is not within 0.1 points of random at 900 s (0.21 against 0.04 tight; 2.21 against 0.18 relaxed): the 25% of the budget given to the random arm is the price, and at the relaxed clock the SH arm still wastes its share. Hedge f = 0.5 does better at the relaxed clock (0.74 at 900 s) and is the better hedge there.
• Prediction (2) held. Larger designs, tight clock, 200 s: hedge f = 0.75 0.66%, between SH's 0.33 and random's 1.85.
• Prediction (3) half held, half wrong. Neither hedge beats random R4 on the small designs at 10 to 30 s at either clock (0 wins at the tight clock; 0 to 3 at the relaxed one). But SH from R2 with eta = 2 is not worse than eta = 3: it is the best strategy tried in several cells. Small designs, tight clock: 3.13 against random 3.33 at 20 s (4 wins, 2 losses), 1.92 against 2.06 at 30 s (7/2), 0.57 against 0.94 at 45 s (6/2; worst design 3.2 against 4.7). Relaxed clock: it beats random on 6 to 8 designs at every budget but its mean is not below random's beyond 10 s (worst-design regret 10 to 12% against 2 to 6%). Larger designs, tight: 0.11 at 400 s onward against random's 0.68 and 0.26 (floor 0.11, lower than eta = 3's 0.30), losing to random only from 900 s. Relaxed: worse than random from 200 s, floor 2.99.
• Reading: a gentler cut (eta = 2) lowers the bias floor at the tight clock, where the R2 ranking is good, and the plain random hedge costs more than it buys. This reverses milestone 3's reading that SH from R2 does not pay on the small designs: at the tight clock and 20 s or more, eta = 2 beats random on 4 to 7 of 10 designs. The relaxed clock remains the stress case, where R2's ranking misleads on a few designs and nothing here removes a 10 to 14% worst-design loss.
• Caveats: eta = 2 was added as one of two variants I tried and not tuned further, but five strategies by two tables by two clocks by four or five budgets is many comparisons, so the win/loss counts are descriptive, not a tested claim; same pools of 50, 10 and 5 designs (three of the five larger ones one family); costs from single-core runs; the seed is shared across strategies (paired), the bootstrap is over seeds within a design, not over designs.
• Next: an eta sweep (1.5, 2, 2.5, 3, 4) with a held-out design split so eta is chosen on some designs and scored on others; the second corner and a non-arithmetic family still need new flow runs.

2026-10-25 · Milestone 10b: an independent rerun with predictions on record (conformal shortlist and pilot bound, larger designs)

• A second run built the same step in parallel and found it already on main (PR #10336). Its numbers reproduce exactly: protocol B R2 m = 16 alpha = 0.2 coverage 0.747 (eps 0) and 0.869 (eps 0.02), 0.49 of the pool routed; protocol A shortlist 0.60 of the pool at coverage 0.90; top-vs-all bound B covers at least 0.81 in all 20 cells, median bound 0.13 to 0.51 except the ripple adder. That is a replication on a different code path (separate edit of the same scripts).
• Predictions written before the output was read, scored against it: (1) B within 0.05 of nominal at alpha 0.2 and above 0.5 of the pool routed: missed narrowly (0.053 under; 0.49 routed). (2) Protocol A under nominal for R2: wrong (0.90 above 0.80; the cost is a 0.60 shortlist). (3) Bound B covers at least 0.8 in every cell and is uninformative above 0.1: held. The tight-clock-only split of protocol A was not run (five groups per clock).

2026-10-25 · Milestone 10: does the conformal shortlist (H4) survive the larger designs?

• Why: milestone 9's "next". Honesty note: I ran the replay first and wrote this entry after, so there are no predictions on record for this step. The script is milestone 4's conformal/replay.py unchanged except that it takes a table path and an output prefix (python3 conformal/replay.py large/results.jsonl ../large/conformal_, 20 s, no flow run); the default call still reproduces the old files.
• Outcome (experiments/large/conformal_results.txt, conformal_summary.json; 10 groups = 5 designs x 2 clocks, pools of 50 to 52; milestone 4 had 20 groups): - Per-design pilot shortlist (protocol B) under-covers on the larger designs. R2, m = 16, alpha = 0.2, exact optimum: coverage 0.747 [0.571, 0.915] against nominal 0.80, where the small designs gave 0.902 [0.858, 0.941]. With a 2% tolerance it is 0.869 (small: 0.945). At alpha = 0.1, exact: 0.905 [0.795, 0.981] (nominal 0.90, small 0.996). It is at or just below nominal here, not conservative as before. Intervals are bootstrap over 10 groups, so they are wide; the drop is suggestive, not established. - It no longer beats random search by as much. R2, m = 16, alpha = 0.2, eps = 0: 0.747 coverage for 0.49 of the pool routed against random search's 0.626 at the same count (small: 0.902 for 0.45 against 0.549). Per routed evaluation the shortlist's edge over random is 0.12 here against 0.35 before. At 2% tolerance: 0.869 against 0.796. - Leave-one-design-out rank shortlist (protocol A) needs a much bigger shortlist. R2, alpha = 0.2: mean shortlist fraction 0.60 (small: 0.18) for coverage 0.90 [0.70, 1.00] (small 0.85). Calibrating the rank quantile on other designs transfers poorly when designs differ this much (mult16 R1 tau is negative, milestone 9), so a calibrated cut has to keep most of the pool.
• Reading: milestone 4's positive result (R2 conformal shortlists are the one rung that pays) weakens on bigger designs: coverage at the nominal level costs about half the pool and the lead over random shrinks. Still a cached-table finding on 5 designs of which 3 are one family; the paper claim should say "on small designs" for the strong form.
• Limits: 10 groups; one corner pair; costs here are counts of routed points, not seconds (R4 is 25x R1 on this table, so counts understate the saving a seconds-based budget would show); no predictions were pre-registered.
• Next: pilot-bound (theory/topk.py) on this table; a second corner; non-arithmetic design family.

2026-10-25 · Milestone 9: five larger designs, and does the routed rung get expensive enough for H2? (planned before running)

• Why: every "next" since milestone 1 names the same blocker: on the ten small designs the routed rung costs 1.3 s against 0.15 s for R1 (8x), so cheap rungs have little to save and H2 cannot be tested. Probe runs (one point each, dc2, 10 ns): mult16 3.7 s, mult24 9.7 s, add64 2.7 s in total. Run the milestone-1 protocol (the same 60 pass sequences from the same seed, two clocks, four rungs, Yosys 0.33, OpenROAD 26Q2 from the nixpkgs binary cache, SKY130 HD) on mult16, mult24, mult32, adder_op64 and adder_ripple64 (experiments/large/, 600 runs).
• Predictions on record: (1) the R4 / R1 cost ratio rises from 8x to at least 25x (mean over the five designs, tight clock), because placement and routing grow faster than the ABC-free R1 count. (2) R1 stays uninformative on the multipliers (median tau-b below 0.3 at the tight clock), and R2 and R3 still mis-rank at the tight clock (median pick regret above 5%) and are near exact at the relaxed one. (3) The ripple adder has fewer than 5 distinct routed values again. If the ratio is under 15x, larger designs of this kind do not fix the H2 blocker and a different family (sequential, memory-heavy) is needed.

### Outcome (experiments/large/: run.py about 50 min on 4 cores, analyse.py, results.txt, halving_replay.py 20 s, halving_results.txt; 600 runs, 96 rejected by ABC/OpenROAD, pools of 50 to 52)

• Prediction (1) held, barely. Mean cost per point (tight): R1 0.77 s, R2 1.25 s (+0.39 s load), R3 2.59 s, R4 19.4 s, so R4 / R1 is 25x (27x with Yosys mapping counted), against 8x on the small designs. Routed from scratch costs 20.6 s in the replay's cost model.
• Prediction (2) mostly failed. R1 is not uninformative on the multipliers: median tau-b 0.31 at the tight clock (I predicted below 0.3; mult32 is 0.45), and 0.12 relaxed (mult16 is -0.28, interval below 0). R2 and R3 median pick regret on the multipliers at the tight clock is 0.4 to 2.1%, not above 5%; at the relaxed clock it is the other way round to milestone 1: 11 to 18% on mult24 and mult32 (R2 tau 0.54 and 0.57), 0% on mult16. So the milestone-1 reading that mapped rungs are nearly exact at a relaxed clock does not carry to bigger multipliers.
• Prediction (3) held: adder_ripple64 has 4 distinct routed values; R1 is constant there.
• First sign of H2 on this benchmark (replay, same code and seeds as milestone 3, budgets 100 to 1200 s). Tight clock, mean regret % (random R4 / SH from R2): 100 s 4.44 / 1.34; 200 s 1.85 / 0.33; 400 s 0.68 / 0.30; SH from R2 beats random on 4 of 5 designs at 100 and 200 s. At 600 s and over random search overtakes it (0.26 vs 0.30, then 0.04 vs 0.30), because SH from R2 stops at a floor of 0.30% (it never routes the true optimum on mult16). Relaxed clock: SH from R2 wins only at 100 s (6.17 vs 8.47) and floors at 5.03%, worse than random from 200 s. SH from R1 is worse than random everywhere on both clocks (4.12 and 11.47% floors); calibrated SH does not help.
• Reading: the cheap rung pays when it is expensive to route, which needs a budget of only a few dozen routed points on pools of 50, and only at the tight clock; the gain is a head start, not a better answer, and a bias floor remains. The relaxed clock is the stress case. Pools are still 50 per design, five designs, one of them nearly degenerate (ripple adder), so the win/loss counts rest on 4 non-trivial designs.
• Limits: five designs, three are one family (multiplier width); one corner; costs are single-core OpenROAD global-route estimates; budgets were scaled by me (100 to 1200 s) to the routed cost and not tuned. The earlier replays (Hyperband, conformal, theory) were not rerun on this table.
• Next: rerun the conformal shortlist and the pilot bound on this table (milestone 4 and 7 scripts take a table path), a second corner, and a design family that is not arithmetic.

2026-10-25 · Milestone 8: Hyperband across the four rungs at equal wall-clock (planned before running)

• Why: PAPER.md lists Hyperband as a missing baseline. Plain SH from one rung commits to that rung's bias (milestone 3: R1 is a loss, R2 is a gamble); Hyperband hedges by running several SH brackets that start at different rungs. Replayed on the cached table with milestone 3's cost model, seeds and pool, so it is paired with random R4 and SH.
• Method (experiments/hyperband/replay.py, no flow run): four brackets, one per start rung (R1, R2, R3, R4), eta = 3, each given B/4 seconds and run as in milestone 3 (largest n0 that fits; an unaffordable bracket returns nothing and its share is lost, not redistributed); the answer is the best routed value over brackets; brackets draw from the whole pool independently (as Hyperband does). Same budgets (5 to 45 s), 400 paired seeds, 10 designs x 2 clocks. Hyperband-lite (R1 and R2 brackets only, B/2 each) as a variant. Comparators recomputed in-script: random R4, SH from R2.
• Predictions on record: (1) At 10 to 30 s Hyperband's mean regret is above random R4's at both clocks, because a quarter of the budget goes to R1 and R4 brackets that cannot pay for themselves in a 50-point pool. (2) It beats SH from R1 at every budget of 10 s or more (it never commits to R1 alone). (3) It does not beat SH from R2 at the relaxed clock for budgets up to 30 s (the R2 bracket gets a quarter of the budget). If Hyperband beats random at 20 s or more, hedging over rungs is worth its cost on this table and milestone 3's reading changes.

### Outcome (experiments/hyperband/: replay.py about 30 s, results.txt, summary.json; the SH-from-R2 and random columns reproduce milestone 3's numbers exactly, a check on the shared cost model)

• Prediction (1) held. Hyperband over four brackets (hb_all) has higher mean regret than random R4 at every budget of 10 to 45 s, both clocks, and beats random on 0 designs in every cell. Tight clock, % (random / SH from R2 / hb_all): 10 s 6.27 / 8.89 / 7.53; 20 s 3.33 / 5.85 / 4.71; 30 s 2.06 / 4.53 / 3.34; 45 s 0.94 / 2.87 / 2.51. Relaxed: 20 s 2.68 / 3.23 / 4.07; 45 s 0.55 / 1.68 / 1.64. At 5 s no bracket is affordable on a quarter of the budget (hb_all is undefined).
• Prediction (2) held. hb_all beats SH from R1 (8 to 10% at 10 s or more, milestone 3) at every budget of 10 s or more on both clocks.
• Prediction (3) half held. At the relaxed clock hb_all is worse than SH from R2 up to 30 s (6.82 vs 5.83, 4.07 vs 3.23, 2.60 vs 2.22) and ties it at 45 s (1.64 vs 1.68). At the tight clock I did not expect it to win and it does: better than SH from R2 at 10 to 45 s (7.53 vs 8.89 at 10 s, 2.51 vs 2.87 at 45 s). The two-bracket variant (R1, R2 only) is worse than hb_all from 20 s (6.8 vs 4.7 tight at 20 s, 5.6 vs 2.5 at 45 s): its R1 bracket spends half the budget on a rung that ranks like noise, and its R2 bracket is too small.
• What hedging buys is a thinner tail, not a lower mean. Worst-design regret at 45 s, relaxed: hb_all 4.6 against 11.8 for SH from R2 (random 1.8); tight: 11.1 against 13.9. The R4 bracket is a random-search insurance policy that SH from R2 lacks, and it caps the loss on the designs where R2 misleads (barrel16, ripple adder). It never makes up the quarter of the budget it costs in a pool of 50 points.
• Limits: brackets split the budget equally and unaffordable brackets lose their share (Hyperband proper allocates by a schedule over a much larger pool); the table is 50 points per design, so the R4 bracket nearly equals random search and all strategies converge to 0 by 60 s (not run here); eta = 3 only; one corner; the paired win/loss counts are over 10 designs.
• Next: BOHB or BO needs a bigger pool than 50 points to say anything (a model has nothing to fit); the larger-design set remains the blocker for H2. Coverage proof and the MLCAD template are still open.

2026-10-25 · Milestone 7d: paper draft and a one-command reproduction (planned before running)

• Why: milestone 7 of the proposal is the paper draft with a one-command-per-figure artefact. 7a to 7c left theory open, but the empirical story across milestones 1 to 7c is enough to write the honest draft and to find out whether every number in it can be regenerated.
• Plan: write PAPER.md using only numbers that sit in a committed results file; add reproduce.sh that reruns every analysis and replay on the cached tables and prints git diff --stat -- experiments. Prediction on record: the replays are seeded, so the diff is empty except for wall-time lines in rung_bias/results.txt.

### Outcome

• PAPER.md written (abstract, related work from the checked ids, setup, results for H1 to H5, the bound and the pilot statistics, limits, what is still missing). Headline stays negative: on small designs, cheap rungs did not pay at equal wall-clock; R2 conformal shortlists are the one positive result.
• reproduce.sh ran end to end (13 tests OK) and left git diff --stat -- experiments empty: the prediction held, and was stronger than predicted (not even the wall-time lines changed, as they are read from the cached table). The first run failed at proof_success/analyse.py for lack of scikit-learn; pyenv.py numpy scikit-learn fixes it (noted in the script header).
• The draft lists what the paper still needs: larger designs (so H2 is testable), a second corner, Hyperband/BOHB/BO baselines, a proof of the coverage, the MLCAD template.

2026-10-25 · Milestone 7c: does the top-vs-all bound survive smaller pilots, and does the hypergeometric fact explain when? (planned before running)

• Why: 7b's B statistic covered everywhere, but with a pilot of 16 from pools of about 50 (a third of the pool) it sees most of the pool's best few. Whether B is a pilot-checkable guarantee depends on the pilot missing them. Sweep the pilot size m in {6, 8, 12, 16, 24} and top in {1, 3, 5}, same 20 groups, both halving starts, 200 pilots x 10 tie-breaks per cell (experiments/theory/sweep.py, no flow run).
• Fact to check, not assume: P(the pool's single best point is in a pilot of m from n) = m / n; P(at least one of the pool's best j in the pilot) = 1 - C(n-j, m)/C(n, m) (hypergeometric). Compare, per m, the empirical share of pilots whose top-top contains a pool top-3 point with this formula (it should match up to sampling error: it is a counting fact, so a mismatch is a bug).
• Predictions on record: (1) coverage of B falls as m shrinks and top grows weaker: at m = 6 at least 8 of 40 group-start cells (pooled over top = 3) fall below 0.8; at m = 24 none do. (2) Coverage tracks the hypergeometric probability that the pilot contains one of the pool's best few: across cells, the cell-level coverage correlates positively (Spearman above 0.3) with that probability at m = 6 and 8. (3) Bound size shrinks with m (fewer pairs seen), so informative-bound cells rise while coverage drops: the trade-off is the result. If B stays above 0.8 nearly everywhere even at m = 6, the 7b result was not a large-pilot artefact and the guarantee can be stated conditionally on a pool-best-in-pilot event of probability m/n.

### Outcome (experiments/theory/: sweep.py about 3 s, sweep_results.txt, sweep_summary.json)

• Prediction (1) half held. Pilot-by-pilot coverage of the top-3 statistic falls with m but less than I predicted: cells under 0.8 (of 40) are 6 at m = 6, 3 at m = 8, 1 at m = 12, 0 at m = 16 and 24 (I predicted at least 8 at m = 6; none at m = 24 held). Mean coverage over the 23 cells with realised regret above 0 is 0.855 / 0.915 / 0.969 / 0.988 / 0.995 for m = 6 / 8 / 12 / 16 / 24. A weaker top (1) fails more: 15 of 40 cells under 0.8 at m = 6, 2 at m = 16 and 24. A wider top (5) is safer (6 at m = 6, 0 from m = 16) and its bound is only slightly larger.
• Prediction (2) could not be tested as designed. Both pools have 50 or 52 points, so the hypergeometric probability that a pilot holds one of the pool's best three is the same in every cell for a given m, and a per-cell correlation is undefined (my design error, found when the Spearman came out NaN; the correlation was dropped from the script). The counting fact itself checks out: empirical share of pilots holding a pool top-3 point is 0.330 / 0.410 / 0.569 / 0.696 / 0.862 against the formula 0.323 / 0.413 / 0.568 / 0.693 / 0.866 for m = 6 to 24.
• A new finding against the story I had told. Coverage is far above that hit probability (0.855 at m = 6 where the pilot holds a pool top-3 point only a third of the time). So "the pool's best few are in the pilot" is not what makes B valid here; a pilot's own best few already have the bad rivals that the halving cut would let through. The m / n assumption I proposed as a conditional guarantee is sufficient at best, not what drives the coverage, and I will not put it in the paper as the explanation.
• Prediction (3) wrong in direction. The median bound grows with m (top = 3: 0.206, 0.242, 0.273, 0.290, 0.333), because more pilot pairs mean a larger maximum. Cells both covered and informative (bound under 0.1) go from 9 at m = 6 to 7 at m = 24. So a bigger pilot buys coverage and costs informativeness; at m = 6 to 8 with top = 3 or 5 it covers 86 to 94% of the time with the same few informative cells.
• Limits: still one table of 20 groups with pools of 50 or 52, so m = 24 is nearly half the pool; coverage is over pilots and tie-breaks within a fixed group, not over designs; coverage is empirical and has no proof. Cells with realised regret 0 (17 of 40) are trivially covered and are excluded from the means above.
• Next: a proof or counterexample for the top-vs-all bound is the open theory problem (the empirical story above says the right event is about the pilot's best few, not the pool's); a second corner or larger pools so n is not tiny; then the paper draft.

2026-10-25 · Milestone 7b: pilot-by-pilot coverage of a halving bound, random pairs versus the pilot's best few (planned before running)

• Why: 7a's last limits: the 40-cell check used the median pilot quantile (flattering), and the one violation showed random-pair quantiles do not control the optimum-versus-rivals pair that halving's regret depends on. The proof of milestone 6 charges, at each cut, the inversion between the best surviving candidate and the points ranked ahead of it, so the relevant pairs involve good points. Test two pilot statistics honestly, one pilot at a time.
• Statistics, from a routed pilot of m = 16 random points (same size as 7a): (A) the 7a statistic, max over 8 disjoint random pairs; (B) top-vs-all: for each of the pilot's 3 best points a (by routed value) and every other pilot point b ranked at or ahead of a by the rung, the value max(0, log y(b) - log y(a)); the statistic is the maximum (b outranking a good point while being worse). Bound for each = sum of the statistic over the cut rungs.
• Test (experiments/theory/topk.py, no flow run): for each of 20 groups and both halving starts (R1: rungs r1..r3, R2: r2..r3, eta = 3, n0 = pool), 300 random pilots x 20 random tie-break seeds. Coverage = share of (pilot, tie-break) pairs where the realised log-regret of halving over the whole pool is at most the bound computed from that pilot alone. Report per group, the median over groups, the worst group, and the median bound size (a bound near the whole spread is trivially covered). Also the pilot cost: 16 routed evaluations against a pool of about 50.
• Predictions on record: (1) A covers less than 0.8 in at least 5 of the 40 group-start cells when judged pilot by pilot (the 7a median check flattered it). (2) B covers more than A in a majority of cells, because it targets the pairs that matter, but is still below 0.8 in at least 3 cells (the pilot's best few are not the pool's best few; 16 of 50 points is a third of the pool, so this is not a small-pilot effect). (3) Where coverage is at or above 0.8, B's median bound is under 0.1 log units only for R2 starts at the relaxed clock; every R1 bound is vacuous (above 0.3). If B covers nearly everywhere with small bounds, the pilot-checkable-bias assumption of the proposal is realistic on this table; if not, the paper's guarantee must be conditional on an assumption we state, not a pilot-checked one.

### Outcome (experiments/theory/: topk.py under 1 s, topk_results.txt, topk_summary.json, 1 new test)

• Prediction (1) held. Judged pilot by pilot, the 7a random-pair statistic (A) covers below 0.8 in 6 of 40 group-start cells (worst: tight adder_op16 from R2, 0.28; also tight adder_op16 from R1 0.60, popcount16 R2 0.66, barrel16 R2 0.79, relaxed adder_op16 R1 0.57 and R2 0.60). The 7a median-pilot check (39 of 40) had hidden this. The ripple adder is the repeat offender: its routed scores take four values, so one pair decides everything.
• Prediction (2) half held. The top-vs-all statistic (B) covers in every cell (minimum 0.807, median 1.000, pooled mean 0.993) and beats A in 22 cells, loses in 0. I predicted at least 3 cells below 0.8 and there are none. Coverage is far above nominal, so B is conservative.
• Prediction (3) held, and it is the real limit. B's median bound is 0.49 / 0.41 (tight / relaxed) from R1, 0.20 from R2 tight and 0.060 from R2 relaxed. Only the last is informative: bound under 0.1 on 7 of 10 groups there, 2 of 10 for R2 tight, 0 of 10 from R1. On the 23 cells with realised regret above 0, B's bound is a median 4.6 times the realised regret. So the pilot-checkable bound is valid on this table but tells a user something only where the rung is already faithful, and there a user would find that out from the pilot's rank correlation anyway.
• Limits: still one table, 20 groups, pools of about 50, pilot a third of the pool (a pilot of 16 from a pool of 50 sees most of the best few, which a real search space of 10^6 points would not; the result may not scale); coverage is over pilots and tie-breaks within a fixed group, not over designs; 17 of 40 cells have realised regret 0 and are trivially covered (reported separately above); B's validity is empirical here and has no proof (the argument needs the pool's best few to appear in the pilot); top = 3 and m = 16 were set before running and not tuned.
• Next: prove or refute a statement for B (it needs the best few of the pool to be in the pilot with a stated probability; that is a hypergeometric fact), vary m and top, then a second corner or larger pools so the pilot is not a third of the pool; then the paper draft (milestone 7).

2026-10-25 · Milestone 7a: a distribution-free pilot quantile of pair inversions, and how much of the halving bound it keeps (planned before running)

• Why: milestone 6's open part. The maximum inversion iota is not pilot-checkable (a 10-point pilot sees a lower bound only). Replace the maximum by a quantile of the per-pair inversion v(x, x') = max(0, log y(x) - log y(x')) over pairs the rung ranks x at or ahead of x' (both orders for ties), and estimate that quantile from a routed pilot.
• Statement (elementary order-statistic fact, to prove in theory/QUANTILE.md): draw n disjoint random pairs from the pool (m = 2n pilot points). Let q = the largest pilot pair value. Then with probability at least 1 - (1 - alpha)^n over the pilot, the share of ALL pool pairs with v > q is at most alpha (sampling without replacement from a finite pool is no worse than the iid case; to be checked by simulation, not assumed). For alpha = delta = 0.2 this needs n = 8 pairs (16 points); for alpha = delta = 0.1 it needs n = 22 pairs (44 points, near a census of the 50-point pools, so reported only as the limit case).
• Experiment (experiments/theory/quantile.py, no flow run): per group and rung r1..r3, all pool pairs; 2,000 pilots of 16 points per group; (a) share of draws with exceedance share <= 0.2 (nominal >= 0.8); (b) q / iota; (c) the quantile bound sum_j q_j over the cut rungs against the realised halving regret of milestone 6 (per-cell mean over 200 tie-breaks), and the share of cells where realised <= bound.
• Predictions on record: (1) coverage (a) is at least 0.8 in every group and rung (theory; below 0.8 with a 95% binomial margin is a bug or a finite-pool failure). (2) The pilot quantile is much smaller than the maximum: median q/iota below 0.5, so the quantile bound is informative (under 0.1 log units) for the mapped rungs at the relaxed clock in a majority of groups, where the maximum bound was not. (3) It is NOT a guarantee for halving's regret, because halving's regret depends on the specific pairs (optimum vs its k rivals) and not on a random pair: realised regret exceeds the pilot-quantile bound in at least 2 of the 40 cells (R1/R2 start x 20 groups). If it never does, the quantile bound is a usable heuristic on this table; if often, the paper must say the guarantee needs a different statistic (for example the inversions against the pool's best few, not random pairs).

### Outcome (experiments/theory/: QUANTILE.md, quantile.py about 7 s, quantile_results.txt, 3 new tests)

• Prediction (1) held. With 16-point pilots (8 disjoint pairs), the share of draws whose pilot quantile leaves at most 20% of pool pairs above it is 0.835 at worst and 0.884 median over 60 group-rung cells (nominal 0.8; none under it). The finite-pool, without-replacement draw does not break the order-statistic bound here; the proof in QUANTILE.md is for iid pairs and the finite pool is checked, not proved.
• Prediction (2) held. Median q / iota is 0.32 (58 cells with iota > 0). The summed quantile bound is under 0.1 log units on 9 of 10 groups for halving from R2 at the relaxed clock (median 0.033, against 0.233 for the max-inversion bound), 4 of 10 at the tight clock (0.112 against 0.352), and 0 of 10 from R1 (median 0.25 against 0.63-0.71: the generic-gate rung stays uninformative).
• Prediction (3) mostly refuted. I expected at least 2 of 40 halving cells where realised regret exceeds the quantile bound; there is 1 (tight adder_op16 from R2: realised 0.130 against bound 0.059). The quantile bound is therefore a usable heuristic on this table (39 of 40) but not a guarantee: the one violation shows the share-of-pairs statement does not control a specific optimum-versus-rivals pair. Using the median pilot quantile (not a per-pilot value) flatters it: a per-pilot bound would be violated more often (not run).
• Limits: one table, pools of about 50, the 16-point pilot is a third of the pool; the quantile is of random pairs, not of the pairs halving uses; the 40-cell check uses the median over pilots, not a pilot-by-pilot test of the bound; no statement with a stated probability for regret yet.
• Next: the pairs that matter (inversions against the pool's best few: a quantile over pairs (x, x') with x among the top-k routed), a pilot-by-pilot test of the resulting bound, and a second corner so the pool is not the limit; then the paper draft.

2026-10-24 · Milestone 6: a regret bound for successive halving from the largest rung inversion (theory), planned before running

• Why: milestones 3 and 4 explain that plain halving from a biased rung loses and that per-point conformal coverage does not transfer to the argmin, but give no bound. The proposal's Method asks for a regret bound for halving as a function of the bias and the number of rungs, with the place where it is vacuous. This step states and proves one, then checks it against the cached table.
• Definition: for a rung r with score s_r and routed value y, the inversion iota_r = max over pairs (x, x') with s_r(x) <= s_r(x') of log y(x) - log y(x') (clipped at 0): the worst the rung can do by ranking x ahead of or level with x' when x is in fact worse by that factor. It needs no calibration and no model of the bias; it is invariant to monotone rescaling of the rung.
• Proposition (to prove in theory/BOUND.md): successive halving that keeps the top k of n entrants by s_r at each cut, and answers with the best routed value among the final survivors, returns y with log y - log y* <= sum of iota_r over the cut rungs (the final routed rung is exact). Proof is by induction: if the optimum of the entrants is cut, at least k entrants rank at or above it, and each of them is within iota_r of it. A property test on random instances checks the statement (it can only fail if the proof does).
• Experiment (experiments/theory/bound.py, no flow run): for each of the 20 design x clock groups of the cached table compute iota_1, iota_2, iota_3 over the pool; the realised log-regret of full-pool halving from R1 and from R2 (eta = 3, n0 = pool size, 200 random tie-breaks); the bound; and the ratio realised / bound. Also what a routed pilot of m = 10 random points sees of iota_r (its own max inversion over the pilot pairs, a lower bound by construction), 200 draws.
• Predictions on record: (1) the bound holds on every group (it is a theorem; a violation is a bug). (2) It is vacuous for R1 (iota_1 near the whole spread of routed values, since R1 ranks like noise: bound above 30% on most groups) and informative only for R2 at the relaxed clock (iota_2 under about 5%). (3) It is loose where it is informative: realised regret is typically a small fraction of the bound, because it charges the worst pair, not the pair that matters. (4) A 10-point pilot sees only a small part of iota (median under half), so iota is not pilot-checkable at the sizes that make the pilot cheap; the probabilistic version (a quantile of inversions instead of the maximum) is the open part and goes in the paper as such. If (4) is wrong and the pilot recovers most of iota, the "pilot-checkable bias" assumption of the proposal is realistic.

### Outcome (experiments/theory/: BOUND.md proof, bound.py about 10 s, src/verified_dse/bound.py with 4 new tests)

• The bound is proved and holds in all 40 cells (20 groups x halving from R1 and from R2, realised mean log-regret never above the sum of inversions; the property test in tests/test_bound.py checks 500 random instances including ties). Prediction (1) held, as it must for a theorem.
• Prediction (2) half held. The generic-gate rung is vacuous: iota_1 is above 0.3 (a 35% factor) on 8 of 10 groups per clock, median 0.36, so halving from R1 has a bound of 0.71 (tight) and 0.63 (relaxed) in log units. But I expected the mapped rungs to be informative at the relaxed clock (under 5%) and they are not: median iota_2 is 0.16 (tight) and 0.14 (relaxed), with only 3 of 10 groups below 0.05 at the relaxed clock, so the R2 -> R4 bound has median 0.35 / 0.23. A single bad pair in a pool of 50 sets iota.
• Prediction (3) held strongly. Realised regret of full-pool halving is 0.10 (tight) / 0.06 (relaxed) from R1, median 15% / 11% of its bound, and 0.000 median from R2 (it finds the routed optimum on most groups; it is not equal-budget, n0 is the whole pool). The worst-pair bound explains why plain R1 halving can lose and says nothing about how often.
• Prediction (4) was wrong in the useful direction. A 10-point random pilot sees a median 0.67 / 0.56 / 0.52 of iota_1 / iota_2 / iota_3 (over 19 to 20 groups, medians over 200 draws), above the half I predicted; per group it ranges from 0 to 1 (crc16 R3 relaxed: 0, because one extreme pair). So a pilot gives the order of magnitude of the inversion but never a certificate: its maximum is a lower bound by construction.
• Limits: one table (20 groups, pools of about 50, one corner); iota is measured on the pool that is searched, so on a new design it is an unknown, estimated only through a pilot; the bound ignores k_j and eta; no probabilistic (quantile) version yet, which is the part the paper needs for a guarantee with a stated probability; the proposition is simple enough that a bandit paper may state it already (not exhaustively checked).
• Next: the quantile version (replace the maximum with a conformal quantile of pairwise inversions, tie to the milestone-4 pilot and test coverage of the bound); then a larger or second-corner design set so the pool is not the limit; then milestone 7 (paper draft).

2026-10-24 · Milestone 5: is equivalence-proof success predictable from cheap features (H5), planned before running

• Why: H5 asks whether a classifier on cheap features predicts Yosys/ABC proof success or timeout, with AUC at least 0.8 on rewrites of held-out designs (refuted below 0.7). The "rewrite" is an ABC pass sequence from the milestone-1 space; the "proof" is a SAT miter of the rewritten gate netlist against the design's synth -noabc netlist (Yosys 0.33 miter -equiv -make_assert then sat -prove-asserts, per-proof timeout 10 s, wall time recorded).
• Data (experiments/proof_success/run.py): the 9 combinational designs of milestone 1 (the FIFO is sequential and is excluded; a one-step miter would prove nothing) x the same 60 sequences (seed 0) x 1 proof each, 4 worker processes. Deterministic flow; proof times are wall-clock and noisy, which is part of the question.
• Label fixed now: success = proof finished within 3 s (primary); 1 s and 10 s reported as sensitivity. Designs whose labels are all one class cannot be scored in leave-one-design-out and are reported as such. Designs are the unit: AUC computed per held-out design with both classes present, plus the pooled out-of-fold AUC.
• Features, all computed before the proof: sequence length, count of each of the 7 passes, rewritten netlist cells and depth (rung 1), reference cells, ratio of cells to reference, input bit-width. Models: logistic regression (standardised) and gradient boosting, leave-one-design-out. Baselines: sequence length alone, cell-count ratio alone, and the design-level base rate (what a model that only knows the design does).
• Prediction on record: most of the signal is which design it is (mult8 and mac4 are the only ones likely to time out), so the pooled AUC will pass 0.8 while the within-design AUC (the part a search could use to pick which rewrites to try) will be near 0.5 to 0.65; leave-one-design-out AUC with design-level features will be erratic with 9 designs. H5 is judged as worded (held-out designs): I expect it to be supported pooled, and I will report within-design AUC separately because that is the practical question. If the labels are almost all "success" at 3 s the test is vacuous and I will say so.

### Outcome (experiments/proof_success/: proof_run.py about 2.8 min + 5.7 min on 4 cores, analyse.py seconds; 752 proofs, 15 designs)

• The first sweep could not test H5. On the 9 combinational designs of milestone 1, 8 prove every one of their ~50 rewrites in under 0.1 s (median 0.01 to 0.05 s); only the 8-bit multiplier is hard (median 11 s; 17 of 50 proved within the 10 s timeout). No design had a counterexample (ABC's rewrites are sound, as expected). So at the 1 s and 3 s thresholds the held-out design either has all-success labels or, for mult8, all-failure: no held-out AUC exists. The prediction "labels almost all success, test vacuous" held.
• 5b (added after seeing this, so not predicted in the plan above): the same 60-sequence draw on multipliers of width 4, 5, 6, 7, 9, 10 (mult_op, parameter W; registered in proof_run.py so flow.py is untouched). Proof time is a steep function of width: median 0.01 s (W=4), 0.06 (5), 0.35 (6), 2.1 (7), 11 (8, 17/50 within 10 s), and 0/50 within 10 s at W=9 and 10. So "hard" is almost entirely a property of the design, not of the rewrite.
• Pooled leave-one-design-out AUC passes 0.8 and means little. Success within 3 s: logistic regression 0.989 (all features) and 0.994 (rewrite features only), gradient boosting 0.73; within 1 s 0.97 / 0.96; within 10 s 0.997 / 0.998 (gbt 0.83). The oracle predictor "the design's own success rate" scores 1.0 / 1.0 / 0.997, so the model is reading design size (reference cell count, and the cell count of the rewrite, which is nearly the same number) and nothing about the rewrite. This is the prediction on record (pooled passes, within-design weak), with the added observation that gradient boosting does much worse than logistic regression across held-out widths because trees cannot extrapolate beyond the sizes seen.
• Within a design the picture is weak and uneven. The only design with enough of both classes is mult8 at 10 s (17 of 50 proved). Leave-one-design-out AUC for held-out mult8: 0.70 (logreg, all features), 0.76 (rewrite features only), 0.65 (gbt); 5-fold CV inside mult8: 0.78 +/- 0.02 (logreg), 0.74 +/- 0.03 (gbt). The one-feature baseline "smaller netlist than the reference" (cells / ref_cells) alone gets 0.81 within mult8, higher than the models, and sequence length alone 0.60. So a rewrite that shrinks the netlist is the easier proof, which is a one-line rule, not a learned model.
• Verdict on H5. As worded (held-out designs, AUC at least 0.8, refuted below 0.7): pooled, supported, vacuously, since the AUC is the design-difficulty signal; within a hard design, between the thresholds (0.65 to 0.78 over the model/protocol variants, a one-feature baseline at 0.81), so neither supported nor refuted. I would not claim "proofs are predictable" in the paper; the claim that survives is "proof difficulty is set by the design's size and structure, and the rewrite's cell-count change carries a modest within-design signal". That gives the search no help in choosing which rewrites to verify.
• Limits: one proof engine (Yosys 0.33 sat, one solver, one timeout; ABC cec, dsec or a different solver would shift every threshold); wall-clock on a shared 4-core container is noisy, and the 10 s label for mult8 is censored; the only hard family is multipliers, whose hardness is well known to grow quickly with width, so "held-out design" is really "held-out width"; 60 sequences per design with 50 usable; no sequential designs; features are the cheap ones named in the plan (no AIG-structure similarity between the reference and the rewrite, which is the obvious next feature since SAT hardness for miters depends on shared internal equivalences).
• Next: add a structural-similarity feature (fraction of AIG nodes equal under simulation signatures, i.e. how many internal equivalences a SAT sweeper could use) and test whether it explains the mult8 within-design variation; add a second hard family with variation inside each design (wider MAC, a checksum tree) so there is more than one design to hold out on; then milestone 6 (theory).

2026-10-24 · Milestone 4: conformal shortlist (H4), planned before running

• Why: H4 asks whether a conformal shortlist keeps nominal coverage of the routed optimum. Replayed on the cached rung_bias table (20 design x clock groups, about 50 points each), no flow re-run.
• Two protocols, experiments/conformal/replay.py. (A) leave-one-design-out rank shortlist: nonconformity of a group = the rank (fraction of the pool, ties broken at random) at which the rung ordering first reaches a point within epsilon of the routed minimum; the shortlist is the top q-hat fraction, q-hat the ceil((n+1)(1-alpha))-th smallest score over the other designs' groups (both clocks). (B) per-design pilot: m random points get routed (R4) values, OLS of log R4 on log rung score, leave-one-out over-prediction residuals, one-sided conformal bound L = fit - q-hat; a point stays on the shortlist if L is at most the best pilot value. Success = the best of pilot plus shortlist is within epsilon of the pool minimum; cost = m + shortlist routed evaluations. alpha in {0.1, 0.2}, epsilon in {0, 0.02}, rungs R1 and R2, m in {10, 16}, 200 random pilots or tie-breaks per group. Compared with random search given the same number of routed evaluations.
• Predictions on record: (A) valid on average but near-useless for R1 (shortlist close to the whole pool, since tau is about 0), shorter for R2 only at the relaxed clock; coverage across designs may fall under nominal because designs are not exchangeable (n = 9 designs is small). (B) per-point coverage transfers poorly to the argmin (winner's curse: the optimum is selected for having a low residual), so coverage of the optimum falls more than 2 points below nominal in at least one setting, which would refute H4 as worded; the shortlist beats random search of equal cost only with R2 at the relaxed clock. If (B) holds nominal everywhere, the winner's-curse worry is unfounded here.
• Limits known up front: 20 groups, one corner, pool of about 50, residuals from 10 to 16 points are noisy, coverage is measured over groups of a single benchmark.

### Outcome (experiments/conformal/, 20 design x clock groups, 200 tie-breaks or pilots per group; replay.py runs in about 35 s, deterministic)

• (A) Leave-one-design-out rank shortlist: coverage holds, usefulness depends on the rung. Coverage over groups is at or above nominal in 6 of 8 cells and within the bootstrap noise in the rest (R1, alpha 0.2, eps 0.02: 0.807 against 0.80; intervals are wide, about +/-0.15, because only 9 designs calibrate). But the R1 shortlist must hold 89% of the pool at alpha 0.1 (63% at 0.2), i.e. no saving; the R2 shortlist holds 33% (18% at alpha 0.2) at coverage 0.90 (0.85).
• (B) Per-design pilot with a conformal lower bound: H4 is refuted for R1 and over-satisfied for R2. R1 coverage of the routed optimum is 0.651 against nominal 0.80 at m = 10, alpha 0.2, eps 0 (0.595 at m = 16): 15 to 20 points below, far outside the 2-point tolerance, and no better than random search of equal cost (0.606, 0.569). At alpha 0.1 it is 0.882 to 0.889 against 0.90 (inside 2 points) but again about the same as random search with the same evaluations (0.83). With R2 the shortlist covers 0.99 against 0.90 (alpha 0.1) and 0.90 to 0.92 against 0.80 (alpha 0.2) while routing 42 to 57% of the pool; random search with the same number of routed evaluations finds the optimum 0.53 to 0.65 of the time. So R2 gives a real saving (about half the routed runs, guaranteed above nominal) and R1 gives a guarantee that fails.
• Prediction check: winner's-curse undercoverage for R1 held (and is the programme's answer to why per-point conformal coverage does not transfer to the argmin); R2 beating equal-cost random search held, but at both clocks pooled, not only relaxed (not split by clock). The (A) prediction of R1 shortlists near the whole pool held (89%). I did not predict the R2 over-coverage of 0.99, so the bound is conservative here; I have not checked why (a guess: the leave-one-out residual of a 10-point fit overstates the error of the full fit, untested).
• Limits: 20 groups from 10 small designs on one corner; groups, not points, are the unit, so coverage differences of a few points are within noise; clock-split coverage not reported; the over-coverage of R2 means the shortlist is larger than necessary (a clock-aware or heteroscedastic residual would shrink it); pilot points are drawn from the pool being searched (their cost counts as routed evaluations, not as a separate calibration set); no theory yet for why the argmin undercovers (milestone 6); replay.py runs at import, so it has no unit tests (same as milestones 2 and 3).
• Next: split B by clock and by design; a heteroscedastic residual; milestone 5 (proof-success model, H5).

2026-10-24 · Milestone 3: successive halving across rungs, plain versus pilot-calibrated (H2, H3), planned before running

• Why: milestone 2 showed a one-shot screen loses to random search, which says nothing about successive halving (SH), which spends cheap rungs adaptively and keeps a widening survivor set. This replays SH on the same cached 1,200-run table, same cost model, same seeds, so it is paired with milestone 2's random and hill-climbing numbers.
• Strategies at equal wall-clock budget B (5, 10, 20, 30, 45, 60 s), 400 paired seeds per cell, regret = routed best found / pool minimum - 1: (a) sh_r1: draw n0 points from the pool, rank at R1, keep the top 1/3 for R2, again for R3, again for R4 (eta = 3); n0 is the largest whose total cost fits B (survivors pay only the incremental stage time, R2 pays its full Yosys + OpenROAD-to-netlist cost since it is a different flow from R1); (b) sh_r2: the same starting at R2; (c) sh_cal: spend 6 routed (R4) evaluations as a pilot (charged to B, and eligible as answers), compute each rung's Spearman rho against R4 on the pilot, start SH at the cheapest rung with rho >= 0.5 (R4 random search if none), the rest as (a). Baselines are milestone 2's random R4 search on the same seeds.
• H2 (as stated in the proposal): SH beats random R4 with a paired 95% interval excluding 0 on most (>= 6 of 10) designs at some budget below 60 s. H3: sh_r1 loses more than 5% (mean regret) on at least one design at some budget that sh_cal brings within 5%.
• Predictions on record: H2 will mostly fail on this table (routed point costs only about 8x R1, the pool is about 50 points, so cheap rungs save little); sh_r1 will be near random at the relaxed clock and worse at the tight clock because R1 ranks like noise and its eta = 3 cut discards the optimum two thirds of the time; sh_r2 will beat sh_r1 at the relaxed clock; the 6-point pilot is too small to separate tau 0.6 from 0.4 reliably, so sh_cal will sometimes start at R1 wrongly. If SH wins clearly the milestone-2 reading (cheap rungs do not pay here) is wrong.
• Limits known up front: pilot of 6 gives a noisy rho; pool of about 50 caps n0; costs are means over the table, not per point.

### Outcome (experiments/halving/, 10 designs, 400 paired seeds per cell, one core; replay.py runs in about 50 s)

• Mean routed regret over designs, % (tight clock; random R4 / SH from R1 / SH from R2 / calibrated SH): 10 s 6.3 / 11.4 / 8.9 / 5.9; 20 s 3.3 / 10.3 / 5.9 / 4.4; 30 s 2.1 / 10.1 / 4.5 / 3.6; 45 s 0.94 / 10.1 / 2.9 / 2.9. Relaxed clock, 45 s: 0.55 / 8.3 / 1.7 / 1.6. Full table in experiments/halving/results.txt.
• H2 is not supported as a mean-regret result and only partly as a win count. At the relaxed clock SH from R2 beats random R4 with a paired interval excluding 0 on 8 of 9 defined designs at 5 s and 6 to 7 of 10 at 20 to 45 s, which meets the proposal's literal "most designs" test, yet its mean regret is higher (1.7 vs 0.55 at 45 s) because one or two designs lose heavily (barrel16 about 12%, the ripple adder about 5%). At the tight clock it wins on 3 to 4 designs and loses on 4 to 6. The calibrated variant is the only one with a lower mean than random, and only at 10 s (5.9 vs 6.3, 3 wins, 0 losses tight; 6/0 relaxed). Mean regret is not the proposal's criterion, so I report both and do not call H2 refuted; the honest summary is "wins where R2 is faithful, loses badly where it is not, net no gain on this table".
• Plain SH from R1 is the worst strategy at every budget of 10 s or more (about 10% regret at the tight clock and 8% relaxed, flat once its n0 reaches the pool size: it never stops mis-ranking at R1). My prediction held. Why it is flat: with eta = 3 and an R1 ranking that is noise, the optimum survives the first cut with probability about 1/3 and the pool is too small to compensate.
• H3 holds, with a caveat that matters. Plain SH from R1 loses more than 5% on 8 of 10 designs at the tight clock (alu8 16.9%, fifo8x4 17.0%, barrel16 11.8% at 60 s) and the calibrated variant brings alu8 to 0.8%, fifo8x4 to 2.8% and barrel16 to 3.0%. But simply starting at R2 recovers alu8, crc16, mult8 and cmp_sat12 as well, so most of the recovery is "do not use R1", which a 6-point pilot only finds when it is lucky. The calibrated variant beats SH from R2 at 20 to 30 s tight (4.4 vs 5.9, 3.6 vs 4.5) and ties it from 45 s (2.85 vs 2.87), and it rarely beats random per design (0 to 1 of 10 from 45 s). Its worst design is the ripple adder (15.5%), whose routed scores take four distinct values, so a rank-based pilot cannot calibrate it.
• Prediction check: random-like SH R1 at relaxed clock held (worse, not equal); sh_r2 beat sh_r1 at relaxed (held); the small pilot sometimes starts at R1 wrongly (held: its tail at 5 s tight is identical to random because the pilot eats the whole budget).
• Limits: n0 is capped by the pool (about 50), so beyond about 30 s SH stops using the budget while random keeps drawing: the 45 s and 60 s columns favour random for that reason, the comparison is only fair up to about 30 s. eta fixed at 3 and a single pilot size; costs are table means; designs are small. The "(wins/losses)" counts cover only designs where the strategy was defined at that budget. No NSGA-II, Hyperband, BOHB or BO yet.
• Next: milestone 4 (conformal shortlist, H4), and a larger design set so the pool is not the limit; also SH with a per-design eta and a pilot-sized sweep.

2026-10-24 · Milestone 2: search baselines at equal wall-clock budget on the cached table (planned before running)

• Why: H2 needs baselines before any multi-fidelity method. The 1,200-run table from milestone 1 holds every rung's score and measured time for 50 to 52 usable sequences per design and clock target, so a search can be replayed on it with no re-running of the flow (cost model: a point at R1 costs the mean t1; at R4 costs mean t2_yosys + t_pnr_total; R2 costs t2_yosys + t_pnr_to_synth_netlist).
• Strategies, all on equal budgets B seconds, regret = routed (R4) score of the best point found over the pool minimum, minus 1; 400 seeds per cell, same seeds for every strategy (paired): (a) random search on R4; (b) hill climbing on R4 (neighbour = Levenshtein distance 1 over pass names within the cached pool, random restart when stuck); (c) screen the whole pool at R1 then spend the rest on R4 in R1 order; (d) the same at R2. Budgets 5, 10, 20, 30, 45 s.
• Limits I know up front: the pool is only about 50 points, so at 45 s random search has seen about 35 of 50 and every strategy converges to regret 0 as B grows; screening the pool at R2 costs about 40 s, which eats most of the range. This benchmark can only show the small-budget end, and it cannot yet speak to H2 at scale. Hill climbing is restricted to the cached pool, so its neighbourhoods are sparse (that handicaps it).
• Prediction (on record): (c) R1 screening does no better than random search at any budget (R1 tau is about 0), perhaps worse; (d) R2 screening beats random at the relaxed clock for B near its screening cost, and not at the tight clock; hill climbing is not better than random because neighbourhoods are sparse. If R1 screening beats random, H1's practical bite is smaller than its tau suggests.

### Outcome (experiments/search_baselines/, 10 designs, 400 paired seeds per cell, one core; replay.py runs in about 75 s)

• Mean routed regret over designs (%, tight clock; random / hill climbing / R1 screen / R2 screen): 5 s 10.7 / 13.5 / n/a / n/a; 10 s 6.3 / 7.4 / 15.0 / n/a; 20 s 3.3 / 3.3 / 6.5 / n/a; 30 s 2.1 / 1.7 / 5.3 / n/a; 45 s 0.94 / 0.61 / 1.08 / 1.27. Relaxed clock: 45 s 0.55 / 0.49 / 1.41 / 1.35.
• R1 screening prediction held for budgets up to 30 s: it is worse than random search on 10 of 10 designs at 10 s and its mean regret is 2 to 3 times random's up to 30 s (it spends 7.4 s of the budget scoring the pool with a score that ranks like noise). At 45 s the means are close (1.08 vs 0.94, tight) and the per-design picture is mixed (beats random on 7, loses on 2), so screening helps where R1 happens to be informative and costs a lot where it is not; the mean is set by the bad designs.
• R2 screening prediction only half held: at 45 s, relaxed clock, it beats random on 8 designs and loses on 1, but its mean regret is higher (1.35 vs 0.55), so the one loss is large. At the tight clock it is 6 wins, 2 losses and a higher mean (1.27 vs 0.94). At every smaller budget it cannot pay for itself: screening the pool of about 50 costs 38 s.
• Hill climbing prediction was wrong: it is not better than random at small budgets (13.5 vs 10.7 at 5 s) but is better from 30 s at the tight clock (1.68 vs 2.06; 0.61 vs 0.94 at 45 s), even with neighbourhoods restricted to the cached pool. Not tested for significance across designs; indicates local structure in the pass-sequence space.
• Reading: on this table the plain baselines are strong and the cheap rungs, used as a one-shot screen, do not beat them at equal wall-clock. That is an argument for H3 (blind screening is not safe) and against expecting H2 from a single screen; it does not test successive halving or a calibrated screen, which spend the cheap rung adaptively. The benchmark cannot show H2 itself: routed points cost only 8x R1 here, and the pool is 50 points.
• Limits: pool of about 50 sampled sequences per design (not the 400-sequence space); mean costs not per-design; no NSGA-II, Hyperband, BOHB or BO yet (proposal baselines); one corner. Not done: tests for the replay script (it runs at import; refactor when milestone 3 reuses it). Results are deterministic (seeded; an earlier draft used Python's salted hash and was fixed before the reported run).
• Next: milestone 3, successive halving across rungs on this table, and a larger design set so the R4 / R1 cost ratio is not 8.

2026-10-24 · Milestone 1: rung-bias benchmark (H1), planned before running

• Design set (10): adder (+, ripple, W=16), 8-bit multiplier, 4x4 MAC, 8-bit ALU, 16-bit popcount, 16-bit barrel shifter, CRC-16 byte update, 12-bit saturating add, 8x4 FIFO. Original small RTL, MIT; four are copied from chip-pnr/chip-ppa-sky130mac.
• Space: ABC pass sequences of length 0 to 3 over {balance, rewrite, rewrite -z, refactor, refactor -z, dc2, dch} (the chip-scriptsearch space, 400 sequences), 60 drawn with seed 0 (the empty sequence plus 59 random), the same 60 for every design; sequences ABC rejects are counted and dropped.
• Rungs: R1 generic-gate cells x depth (Yosys/ABC -g); R2 SKY130 HD mapped area x no-wire OpenSTA period; R3 post-detailed-placement area x period; R4 global route + repair_timing area x period (the reference, "routed"). Score = area x period (um^2 ns), as chip-scriptsearch. Flow is chip-pnr's OpenROAD script, 40% utilisation.
• Clock target: the design's own baseline (empty-sequence) no-wire period ("tight", where wires force repair) and 1.5x that ("relaxed"), to see whether the answer depends on repair pressure.
• Analysis fixed now: Kendall tau-b of each rung against R4 per design and period, 95% bootstrap interval over sequences (2000 resamples); regret of the rung's pick (mean over ties) = R4(pick)/min R4 - 1; whether the rung's top 5 contains the R4 optimum. H1 holds if R1's tau is below 0.7 on at least 4 of 10 designs (at the tight period) and is refuted if tau is at least 0.7 on 9 or more. Also report R2 and R3, and rung wall times.
• Expectation I am on record with: R1 will do worst, R2 will already be close to R4 on most designs. If R1 is fine, H1 is refuted and the programme's premise (cheap rung is biased) needs rethinking for pass-sequence spaces.

### Outcome (same day, experiments/rung_bias/)

• 10 designs x 60 sequences x 2 clock targets = 1,200 runs; ABC aborted on 196 (all of them contain a dch followed later by rewrite/refactor, though 44 successful runs have that pattern too, so it is a necessary, not a sufficient, condition; 10 of the 60 sequences per design failed), leaving 50 usable sequences per design (52 for the ripple adder, whose 4 distinct routed scores make it nearly uninformative).
• H1 holds. The generic-gate rung (R1) has tau-b below 0.7 against routed area x delay on all 9 designs where it is defined (median -0.04 tight, -0.01 relaxed; with a 95% interval entirely below 0 on popcount16 and crc16 at the tight target). For the ripple adder R1 is constant, so tau is undefined (counted as uninformative). R1's pick costs a median 13.5% (tight) and 20.0% (relaxed) of routed area x delay.
• My expectation was half wrong. I expected R2 (liberty-mapped, no wires) to be close to routed on most designs. At the tight clock target it is not: tau below 0.7 on 6 of 10 designs, median 0.59, median pick regret 10.5%. At the relaxed target it is: tau below 0.7 on 3 of 10, median regret 0.0%. Repair pressure, which R2 cannot see, drives the bias. R3 (after placement) is no better than R2 at the tight target (7 of 10 below 0.7), because the timing repair that follows is what reorders designs.
• Rung wall time on these small designs: R1 0.15 s, R2 0.46 s of Yosys plus 0.32 s of OpenROAD load, R3 0.51 s, R4 0.80 s per point (OpenROAD stage times; add the 0.46 s mapping for cumulative cost) on one core. The routed rung (0.46 s mapping + 0.80 s OpenROAD = 1.3 s) is only about 8x the generic one (0.15 s) here, so the savings multi-fidelity search can claim on this benchmark are small; the benchmark needs larger designs before H2 is testable.
• Caveats: one library corner and one utilisation (40%); "routed" is global-route-estimated with repair_timing, not detailed-routed; sequences are the same 60 for every design; the clock targets are tied to each design's own baseline, so targets differ across designs; bootstrap intervals resample sequences within a design, not designs; no multiple-comparison correction.
• Next: milestone 2, search baselines at equal budget on this cached table; and add larger designs (the 0.8 s routed rung makes the cost ratio the weak point).

2026-10-24 · Programme opened: proposal written

• Wrote PROPOSAL.md (question, 12 related works, gap, hypotheses H1 to H5, evaluation, milestones). No experiment run.
• All arXiv and DOI ids were looked up with cite_check.py. One id I had recalled for a multi-fidelity HLS paper (2106.09221) resolved to an unrelated physics paper and was dropped, so that paper is not cited.
• Next: milestone 1, the rung-bias benchmark (H1). Planned before running: 8+ designs, a pass-sequence space, four rungs on SKY130 as in chip-pnr; the analysis is Kendall tau of each rung against routed area-delay per design.