Hierarchy-Aware Yield Surrogates with Hyperbolic Parameter Positions

Before a chip ships, designers check that it still works when every transistor is slightly different from its neighbours. This manufacturing spread is called process variation. The check, yield analysis, runs the circuit simulator thousands of times with randomly perturbed device parameters. Machine-learned surrogates cut this cost by learning a map from perturbation to performance. The strongest current approach treats the perturbations as a flat table, though, and it can only accept a few hundred of them. For a small 32×2 SRAM (on-chip memory) array with 1,152 random parameters, it must throw most of them away. It also cannot be reused on a larger array, because a larger array has a different number of table columns.

We propose a different input format. Each random parameter is a token: its sampled value plus a coordinate saying where it sits in the circuit's hierarchy (array, bank, column, cell, transistor) or along a wire's resistor-capacitor tree. The coordinates come from a hyperbolic embedding, meaning a placement of the hierarchy's nodes in a curved space where room grows exponentially with distance from the centre, as a tree's node count does. A set model with attention reads all tokens, however many there are. It can therefore be trained on small circuits and applied to larger ones. The bet is that hierarchy position is what decides how a parameter's variation affects timing, and how strongly it correlates with other parameters. If so, a compact, low-distortion encoding of that position should matter.

Core Claim

Our claim is that a yield surrogate whose inputs are value-plus-position tokens can do three things a fixed-column tabular model cannot. It can use every variation parameter without heuristic pruning. It can transfer across circuit sizes and across corners, where a corner is one fixed combination of supply voltage and temperature. And at equal simulation budget it can estimate failure rates on large SRAM arrays at least as well as the tabular approach.

The hyperbolic part is a narrower, falsifiable sub-claim. Low-dimensional hyperbolic positions should beat Euclidean positions of the same size, with the largest gap on deep, irregular trees and the smallest on regular grids. If that sub-claim fails, the token-set surrogate still stands on its own, and we will report the hyperbolic result as negative.

What Exists and Where This Differs

Three works define the starting point, and each plays a different role.

Breaking the Tuning Barrier is the closest competitor. It uses TabPFN, a pre-trained tabular in-context learner, across many voltage–temperature corners, and adds a gradient-boosted tree selector that cuts 1,152 parameters to about 48. It reports 1.10% mean relative error on the 1,152-dimensional SRAM and a 24.1× speedup over Monte Carlo with 170 simulations. It motivates our work because it shows that sharing data across corners pays off: error falls by up to 72%. It also constrains our work, because any new method must match this sample efficiency. It has no notion of where a parameter sits in the circuit, and it is tied to a fixed number of input columns. Removing those two limits is our change.

OpenYield supplies the testbed: scalable SRAM arrays with wire parasitics and variation in the peripheral circuits. It also supplies a warning. Omitting these second-order effects understates read delay by up to 6.87× and write time by 8.45×. We therefore keep all such effects in every experiment.

SyncTREE shows that wire timing on resistor-capacitor trees can be learned with linear-cost, two-pass message passing. It reaches 0.0106 ps delay error on 414,639 RISC-V segments. However, it uses nominal resistance and capacitance values and Euclidean features. We reuse its tree data, add random perturbations to it, and use it as a structural baseline.

Two netlist models embed circuit structure in flat space: DE-HNN, which links partitions through virtual nodes arranged as a tree, and StructRTL, which uses Laplacian positional encodings. Both predict only nominal metrics. The research file found no work that joins process variation with hyperbolic embedding.

The geometry comes from three sources. We take the method from Poincaré embeddings and the Lorentz model. These report a 5-dimensional hyperbolic embedding reaching a mean average precision of 0.823 on WordNet, where a 200-dimensional Euclidean one reaches 0.168. The constraint comes from the Lorentz paper's own warning that grid-like or cyclic data can be distorted by negative curvature. SRAM cell arrays are partly grid-like, so that warning applies directly here.

Research Program

We first build a hierarchy tree for each circuit. For SRAM, the tree follows the instance hierarchy down to individual transistors, with peripheral blocks and wordline and bitline wire trees attached. For interconnect, the resistor-capacitor tree itself is the hierarchy. We embed each tree once, offline, in a low-dimensional Lorentz model using Riemannian gradient descent, following the Lorentz-model paper. Every random parameter then inherits the coordinate $p_i$ of the device it perturbs.

The surrogate is an ordinary Euclidean set transformer. Each token is the parameter's normalised value $x_i$, its parameter type, and its tangent-space coordinates. Physical row and column indices are appended to every variant, so the grid structure is never hidden from any model. Geometry enters attention in one place, a distance penalty:

$$a_{ij} = \frac{q_i^\top k_j}{\sqrt{h}} - \beta\, d_H(p_i, p_j),$$

Here $q_i, k_j$ are the query and key vectors, $h$ is their width, $d_H$ is the hyperbolic distance between the two parameters' positions, and $\beta$ is a learned scale. Parameters that share a deep common ancestor, such as two transistors in one sense amplifier, attend to each other strongly. Unrelated subtrees stay separated in few dimensions.

This design avoids the main cost of hyperbolic neural networks, namely expensive and numerically fragile operations on curved space, as noted for Hyperbolic Neural Networks. Here only fixed positions and one distance per attention pair are hyperbolic.

The corner, meaning supply voltage and temperature, enters as a conditioning token. The model is trained across corners, with an active-learning loop that picks the next simulation where the model's ensemble disagrees most. That loop deliberately mirrors the competitor's uncertainty-guided sampling, so the two methods differ only in how they represent the input. Failure probability is estimated by running the surrogate on large Monte Carlo samples, after a final check of borderline samples with real simulations.

Baselines

The naive reference is plain Monte Carlo with circuit simulation. It provides the ground truth on every benchmark and the cost every speedup is measured against.

The strongest sampling-only competitor is Adaptive Clustering and Shift (ACS) importance sampling, run with the OpenYield code. OpenYield reports 19.8× speedup over Monte Carlo at comparable accuracy on the 32×2 array.

The strongest learned competitor is TabPFN with gradient-boosted feature selection and uncertainty-guided active learning, from Breaking the Tuning Barrier. It reports 1.10% mean relative error on the 1,152-variable SRAM and needs 170 simulations for its 24.1× speedup. We will run it on identical simulation pools, corners and budgets, using its zero-tuning defaults. Our model will receive a tuning budget limited to the same validation simulations. To beat it, we must match its error at 170 simulations on the 32×2 array. On larger arrays, which it cannot use without re-selecting features, we must show lower error or fewer simulations.

The structural competitor is a Euclidean graph network on the netlist, built from SyncTREE's two-pass message passing and conditioned on perturbed parameter values, trained on the same data.

The decisive ablations use the identical set model with the position encoding swapped. The variants are hyperbolic, Euclidean of equal dimension, Euclidean at 8× the dimension, hand-made hierarchy indices, and no positions. This isolates whether the geometry, rather than the tokenisation, does the work.

Why not just…?

Why not just give TabPFN more features or a better selector? Better selection can lower error on one fixed array. It cannot transfer to an array of a different size, because the selected columns no longer exist there. The 500-feature ceiling reported in Breaking the Tuning Barrier also forces pruning before learning starts. On same-size evaluation this is a real threat, and our model may only tie. The size-transfer experiment is where the difference must appear.

Why not just use hand-made coordinates such as bank, row, column and transistor slot? For a regular SRAM this could work as well, and we treat it as the most dangerous alternative. It does not exist for irregular resistor-capacitor trees or peripheral logic. The variation-aware SyncTREE benchmark exists to test that regime. If hand-made indices match hyperbolic positions on SRAM and the hyperbolic advantage appears only on irregular trees, we will report exactly that.

Why not just use a Euclidean graph network or Laplacian encodings, as StructRTL does? WordNet results suggest Euclidean encodings need far more dimensions for deep trees. Circuits are not WordNet, however, and StructRTL shows that Euclidean structural models work well on nominal metrics. The equal-dimension and 8×-dimension Euclidean ablations settle this. We only claim an advantage where it survives the larger Euclidean model.

Why not just use first-order sensitivity propagation along the tree? Wire delay is close to linear in small resistance and capacitance changes, so a linear sensitivity model may suffice for interconnect. We include it on the wire-tree benchmark. Failure regions of SRAM read and write are strongly nonlinear once parasitics are included, which OpenYield documents. That is where a linear model should break down, and we will check that it does.

Proposed Experiments

The first experiment is a matched-budget comparison on OpenYield 32×2 arrays with all second-order effects, across all corners. We measure failure-probability relative error against Monte Carlo ground truth and the number of simulations needed to reach 1% error. The comparison runs over 5 seeds, against every baseline.

The second experiment tests size transfer. We train on 32×2 and 64×2 arrays, then evaluate on 128- and 256-row arrays. We report error with no new simulations, and error after 50 and 170 new simulations. TabPFN is re-run from scratch at each size as its fair counterpart.

The third experiment adds variation to SyncTREE trees. We perturb resistance and capacitance with spatially correlated and independent components and simulate delay distributions ourselves. No reported result was found on Lacuna for variation-aware interconnect delay, so all numbers there are new. Metrics are error in the mean and 3σ delay, and a Wasserstein distance between predicted and simulated distributions, broken down by tree depth.

The fourth experiment is the curvature diagnostic that the Lorentz paper's warning calls for. We learn the curvature per substructure and measure, per benchmark, how much the hyperbolic-versus-Euclidean gap grows with tree depth and branching. This gives the predicted pattern: a gap near zero on SRAM cell grids and a growing gap on deep irregular trees.

Three decisive checks determine the outcome. If the Euclidean model at 8× dimension closes the gap on irregular trees, the hyperbolic sub-claim is dropped. If size transfer with no new simulations is no better than TabPFN at 50 new simulations, the token-set claim is weakened to sample efficiency alone. If neither advantage holds, the result is a well-controlled negative finding about hierarchy priors in yield analysis.