Mendicant

the correspondence

Take a placed board. Put its pins in angular order about the board's centroid: that sequence is the backbone. Take each net's Euclidean minimum spanning tree and call its edges base pairs. Now every net is a chord across a circle of pins, and two chords that interleave — each with one end inside the other's arc — cannot be drawn on the same layer without crossing. In RNA that pair has a name: a pseudoknot. The board folds to a dot-bracket string, the same notation a biologist reads, and the pages of its circle graph are the layers the chord diagram demands.

Nussinov's recurrence, the 1978 dynamic program that maximises non-crossing pairs, run with the pairs fixed rather than chosen, then counts exactly the nets that must leave the top layer. We call that count displaced.

what the fold is not

It is not a lower bound on layers, and the first board we folded said so. A mouse controller — 68 nets, 219 pins, placed by a person — folds to 10 pages and 1,013 chord crossings, 296 of which are flightlines that genuinely intersect. freerouting builds that board on two layers with ten vias. Copper detours; a chord cannot. So the fold is wildly pessimistic as a layer count, and that is fine, because what it actually measures is how much detour a placement is asking the router to find.

between boards it is a size prior

Across identity boards the crossing count correlates with the router's via count at +0.55 — and the pin-pair count alone gets +0.53. Hold board size and almost nothing is left. Pooled over 900 boards, holding pairs, it is indistinguishable from zero. This is exactly the trap ISOnet fell into, and it is why we now measure everything twice: once across boards, where size dominates and any feature looks clever, and once within a single board, where size is constant and only the placement varies.

within a board it is not

Over 8,423 placements of 548 boards with six or more placements each, on the boards with enough clean routes to correlate, the crossing count tracks the vias freerouting spent — and keeps doing it when wirelength is held constant, which is the test that matters. Half the signal is not wirelength and not density.

Two things carry nothing, and we say so: the page-count dynamic program adds no signal past the raw crossings, and the Zuker-style stacking features — bus-like parallel runs, which we expected to matter — carry nothing at all on boards.

what it does not do yet

It orders vias, not verdicts. Asked to separate the placements of one board that route clean from the ones that fail, the fold scores an AUC of about 0.55 to 0.57 — barely above chance. A clean route that costs more vias is still a clean route, and the step from “this placement will cost the router more detours” to “this placement will defeat it” has not been shown. It is the first feature we have measured that varies within a board independently of wirelength, which is precisely what an anneal-time judge needs, and that is the whole of the claim.

the next organism

A slime mould, Physarum polycephalum, solves shortest-path problems by growing tubes that thicken with the flow they carry and starve without it. A network that does that is a global router that finds its own trees — deterministic, explainable, and fast enough to run inside the anneal loop where the analytic density estimate sits now. It routes a placement coarsely in about half a second and, at pad resolution, opens an escape window around every pin in about six.

How walled in the pins are — how many have no way out at all — predicts a failed route at AUC 0.829 held out on 1,774 boards that no tuning touched, against 0.713 for the net count, 0.739 for the fold and 0.68 for RUDY's peak, and it keeps ρ +0.42 with net, pin and footprint counts held. That is the best board-difficulty reading this corpus has produced, better than ISOnet, better than the fold. The negotiation is what makes it: the same mould with every net grown alone scores 0.740 against 0.803, so two thirds of its margin over the net count is the nets competing for room rather than the trees themselves.

Then a referee asked the sharper question, and the answer costs the instrument most of its mystique. A count of pads whose nearest neighbour sits closer than a track and two clearances — a ruler, computed in no time at all — reads the same held-out boards at 0.821, and the difference of +0.008 has a paired interval over boards of [−0.006, +0.022]. Spearman between them is 0.78. So between boards the eight seconds buys a pitch counter. What survives is smaller and more specific: holding size and three such counts, the windows keep ρ +0.105 and the coarse mould's saturation +0.206, and the readings stack — a ten-fold logistic goes from 0.712 on the net count to 0.852 on the counts to 0.868 with the mould's readings added.

And the within-board question, which this page reported as flatly null, has a small real answer at scale. On 989 placements it was 0.55, p = 0.32. On 2,045 boards that hold both a clean placement and a failed one it is 0.574, 1,106 ordered right against 753 wrong, p = 1×10⁻¹⁵ — six hundredths of AUC, replicated under each router alone, strongest at 10 to 49 nets and absent under ten. It is the coarse mould that does it, not the pad-resolution windows, which stay at 0.47. Real, weak, and not what an anneal-time judge would need.

There is a reason it can only ever be weak, and it is not the instrument. The two routers agree on a board's own placements at Cohen's κ = 0.11 [0.05, 0.17], where each router against its own copies nudged by 0.05 mm agrees at about 0.81. A router is a reliable rater of itself and the two are near-chance raters of each other exactly where the within-board question is asked. Some of what we have been trying to predict is which router got lucky — so a judge that ranks a board's own placements without naming a router is bounded, and the bound is not in the geometry.

So the thread turned. If the judge cannot rank placements but can rank boards, the way to lift the clean rate is not a better judge — it is a better router. Running both and keeping whichever closes the board takes the bank from freerouting's 54.0% clean to 74.3%, and that is now what the build does.

the loop, compiled

The mould's inner loop — PathFinder's prices, a block-tridiagonal Poisson solve, Tero's update — is now Rust, and it is the same loop. The time was never Python: profiling put 70% of a coarse route inside batched LAPACK solves, at a flat 15 to 20 µs a system whatever the batch. The core does those rows three ways cheaper — the coupling to the next row from a Cholesky factor rather than a solve, every inner loop a dot product along a row, and four nets through the solve abreast as SIMD lanes, because at thirty-two cells a side the triangular loops are too short to vectorise along. 2.7 µs a row-solve against Accelerate's 15 to 20.

Measured on 131 judged placements, both backends, all six forms of the mould: the worst relative difference in any scalar is 7×10⁻¹², every integer scalar identical on every placement, and every headline AUC equal to four decimal places. The windows go from 2.09 seconds a placement to 0.123, the coarse mould from 0.185 to 0.026. Nothing in the paper moves, and nothing about the ceiling moves either — a faster instrument orders a board's own anneals no better. What it changes is where the instrument can live: at an eighth of a second the windows are a gate a build can afford on every candidate, where at eight seconds they were something you ran overnight.

the fold, on a chip

A crossing on a printed circuit board costs a via, which is cheap enough that the router will take it. On a photonic integrated circuit a crossing is a physical device and costs about half a decibel of the light going through it, and the placer that leads that field counts crossings by sampling straight lines every hundred iterations. That is a place where the fold is not a proxy for anything — it is the quantity.

So the fold was pointed at one. Waveguides run left to right, so the backbone is the channel rather than the centroid, and the pairs of nets whose spans overlap and whose ends interleave are an exact floor on the crossings any router must draw. A placer built on it — stages by longest path from the couplers, order within a stage by barycentre sweeps and then sifting with vertical flips as moves, rows by isotonic projection — lays out a 287-net chip in 1.4 seconds. The judge is LiDAR, an open-source photonic router from a different group, and the benchmarks are its own, which ship with layouts drawn by hand.

Why a hand layout can be beaten on crossings at all: a stage whose devices each have one input and one output cannot lower the total by reordering, so the seven the fold removes come from vertical flips of the MMIs and the free order of the output couplers, which a person left as the netlist named them. What this is not: a general placer — it takes the feed-forward structure every chip in these suites has — and not a rerun of Apollo, whose repository its paper calls open-sourced and which is empty, so its rows are its published table on netlists that are the same and a die and router setting the paper does not state. And the transfer runs the other way: over thirteen bent copies of a hand layout the channel floor tracks LiDAR's crossings at Spearman +1.00 and the mould's blocked-pin count at −0.64. The mould does not read a waveguide field, where an MMI's outputs sit 1.25 µm apart; it calls 118 of 158 ports blocked on a chip LiDAR routes clean.

the paper, and its referee

This thread is written up as a paper, and the paper has been through a review that asked for a major revision and got one: four testable claims, each measured rather than answered. Two of the referee's bets came apart in opposite directions. The ruler above is the one that landed — a geometric count reproduces the instrument's headline, and the paper's abstract now carries it alongside the 0.829. The one that did not is the claim that the mould collapses to a resistive current-flow map: one iteration with no pricing scores 0.645 where forty score 0.766, so the dynamics are doing something, though the correction cuts the negotiation's own margin at the pins from about +0.12 to +0.08. A classical PathFinder control, swept on its own constants, keeps the mould's margin at +0.025 [+0.001, +0.048] and gets worse when given accumulated usage rather than last iteration's prices.

Two things the revision took out rather than added. The ceiling is restated as a bound on a router-agnostic judge, with the per-router bound stated beside it, and the flat assertion that the signal is "not in the geometry at any resolution" is withdrawn as the assertion it was. And counting a router's timeouts as failures — 1,178 held-out rows no router answered, which are the big boards — raises every score and narrows the mould's margin over the plain net count from +0.090 to +0.047. A search of the literature found no published PCB placement-routability estimator with runnable code to compare against; the paper says so and invites the comparison.

furthering

The pairwise reframe — predicting which two nets will fight, rather than scoring a whole placement with one number — is the reading of this thread that has not been tried, and the one the correspondence most naturally supports. Beneath it sits the finding that keeps coming back: the crossing count is a real within-board signal about how a board routes and a weak one about whether it does, and the two are not the same question. The fold went into ISOnet's inputs on that hope and came out again the same morning, at −0.005. Where it earns its place is as a via cost inside Quorra's anneal, which is measured on the Quorra page, and on substrates where a crossing is not a via but a device.

the other threads

All three, and how we work.