A Richter scale for geometric complexity

Two parts can have the same volume, the same bounding box, and completely different levels of difficulty for a solver — or for a neural surrogate — to get right. Everyone in this field knows that intuitively. Almost nobody measures it. We decided to try.

The question we wanted a real number for: “how hard is this shape?” Not vaguely — a single index, comparable across a sphere, an industrial bracket, and a fractal, the way the Richter scale lets you compare a tremor to a catastrophe on one axis.

The measurement, not the metaphor

The instrument is N_eps: the number of sample points a greedy algorithm needs to cover a shape’s surface at a fixed tolerance (eps = 1.0, on a body normalized so its largest extent is 2.0), sampled against an implicit grid of 176^3. What drives N_eps up is local feature size — thin walls, sharp corners, tight fillets need denser sampling than smooth open surfaces need. The search is capped at 6,000 points; anything that doesn’t converge under that cap is reported as censored, not silently reported as if 6,000 were the true answer.

We ran this against a permanent, frozen reference set — the same bodies, the same script, every revision, adding a column rather than overwriting one. That matters more than it sounds: it means a claim made in one revision can be checked against the exact same measurement a revision later.

The ladder

body	N_eps	index
sphere	6	1.0
torus	70	2.8
real industrial bracket (55_80)	1,360	5.0
gyroid, period 1	3,192	6.6
Menger sponge, iteration 1	4,095	7.0
Menger sponge, iteration 3 (censored, extended cap)	11,904	9.0

A sphere sits at the bottom, a torus is already 12x harder to sample, and a real bracket we work with — not a toy shape, an actual part with 1,360 points needed to cover it at tolerance — anchors the middle of the scale. A Menger sponge, which is a fractal, tops it.

The finding I didn’t expect

The scale is anchored at three points: sphere (N=6, index 1.0), the real bracket (N=1,360, index 5.0), and the Menger sponge at its third iteration (N=11,904, index 9.0, using an extended search cap since the default one censors it). I assumed, going in, that a straight logarithmic line through all three would work. It doesn’t.

A straight line from the sphere through the bracket would predict roughly 310,000 points at index 9.0. The fractal actually needs about 11,900. That’s a 25.9x discrepancy between what a naive straight-line extrapolation predicts and what we measured. So the scale is piecewise-linear, not log-linear: between the sphere and the bracket (index 1 to 5), each +1 of index costs roughly 3.88x more sample points; between the bracket and the fractal (index 5 to 9), each +1 costs only about 1.72x more. Complexity doesn’t compound the same way in both halves of the range. That’s not a modeling choice — it’s what the measurement told us, and it’s the kind of thing you only find by actually running the ladder instead of assuming the shape of the curve.

The honesty rules that make the number usable

A number like this is worthless if it quietly lies at the edges, so we built in rules rather than leaving them to judgment calls later:

• If the greedy search is censored (hits the 6,000-point cap without converging), the resulting index is reported as a lower bound — “index >= X.X” — never as if it were the true value.
• If a shape’s true index would exceed 10, it’s flagged above_scale and reported as “>10”, never silently clamped to fit the chart.
• Censored and off-scale are two different flags. Conflating them would hide which limitation you’re actually running into.
• The raw N_eps and the underlying local-feature-size statistics travel with the index everywhere it’s reported, so nobody has to trust the single number in isolation.

Where the ladder is honestly incomplete

Menger sponge iteration 3 is where this got interesting in an uncomfortable way. Its geometric detail is three times finer than iteration 2, but it only needed about 17% more sample points to reach the (extended) cap. That’s suspicious on its face — three times the detail should cost more than 17% more points. The answer is that our 176^3 background grid doesn’t resolve the third iteration’s fine structure at all. So that N_eps isn’t just a lower bound because the search was censored — it’s a lower bound of a lower bound, and we recorded it that way rather than smoothing it into something that looks more finished. Closing that gap needs a grid at least 528^3, which is 27 times the memory footprint. The true sampling budget of a fractal at that resolution is, honestly, still an open question on our side.

We also re-ran the whole ladder against the previous revision’s published counts: 10 out of 10 bodies reproduced bit-exactly. That’s the check that tells us the sampling chain hasn’t drifted silently between revisions — a boring result, and the right one to want.

The practical reading, once you have this: “your part is a 6.3 on the scale, between a gyroid at 6.6 and the industrial bracket at 5.0” is a sentence you can use to decide, before you commit compute, whether a fast surrogate is even the right tool for that geometry.

Where would your hardest part land on a scale like this? I’d like to hear specific geometries people think would break it.