WorksComputer Science
Separating learning from search and feedback in budgeted inverse design of periodic unit cells
Abstract
To design a periodic material, engineers choose the shape and dimensions of a repeating cell to meet target properties. With few simulations, the benefit of a learned predictor can be hard to separate from the effect of which designs the search tries and how it uses simulator feedback. We compare two ways to predict properties in a library of 80 cell architectures, with up to 30 simulator calls per target. For each architecture, both searches use a table of predicted properties at different dimensions. One fills the table with predictions from neural networks. The other fits a simple model to the existing simulations for that architecture. Both searches use the difference between the predicted and simulated properties to adjust the next design. We generated 200 targets from simulated designs after fixing the analysis plan. The two searches showed no detectable difference in how often they matched all three properties within 2% or in the mean error of their returned designs. The upper limit of the 95% confidence interval for the gain in overall success rate was 4.5 percentage points. Follow-up controls on these targets changed success from 83.5% to 36.0% with a degraded table and 96.5% with an oracle table. In separate tests, using the simulation result to adjust the next design increased success for both types of table. Results cover one library and a coarse 32^3 voxel simulator. Designers can use this comparison to judge what a learned predictor adds when the search, feedback and budget are the same.
Introduction
To design a periodic material for specified stiffness and conductivity, a designer chooses the geometry of its repeating unit cell and sets its dimensions. Inverse homogenisation uses cell simulations to work from desired material properties back to geometry [29]. With a library of candidate architectures and a limited budget, every simulation spent sizing one architecture leaves fewer calls to test others. A stored example may be far from the target even when changing its density or shape would give a good match.
Precomputed microstructure families give designers a way to interpolate from stored geometries [28]. Learned models can also predict a geometry for prescribed properties or generate designs across families [4, 35]. Both routes leave decisions for the search. It has to choose which architectures to simulate, where to start within each one and how to use the results of earlier calls.
We ask whether learning adds to a search that already makes these decisions with the aid of simple catalogue fits. A response table predicts the properties for a range of dimensions of one architecture. The search reads each table to find the dimensions that come closest to the target. After a simulation, it can adjust the predictions using the difference between the table and the observed properties, which we call the residual. We measure the effect of the full search by comparing it with local search from retrieved examples. To measure what learning adds, we replace the learned tables with catalogue fits and keep the search rules fixed.
Our benchmark uses one library of solid–void cells and a common catalogue of simulated examples. The library includes cells defined by periodic fields, strut lattices and blends of two periodic fields. The targets specify two measures of stiffness and one of conductivity. The main target sets come from simulated reference designs. We choose targets that none of the stored designs can meet at the chosen tolerance so the benchmark tests whether a search can improve on retrieval. The searches see the target properties and can return any architecture in the library. A common voxel simulator verifies the returned designs.
We address two research questions.
Under a fixed call budget, what do learned tables and simulator feedback each contribute to search performance?
How do the choice and starting dimensions of architectures affect the search, and how does table-guided search compare with bracketing, Bayesian optimisation and Nelder–Mead search (Sect. 5.2)?
The benchmark and matched comparisons give designers a way to decide whether to invest in a learned predictor or improve how they spend their simulation budget. The confirmatory comparison is the primary evidence about learning (Sect. 6.1). Other tests examine feedback, the choice of search and the effects of changing the targets, tolerance or verification grid.
Related work
Updating predictions with simulations
Approximation-model management uses agreement between predicted and simulated improvement to decide where to trust an inexpensive model ([1]). Space mapping adjusts the inputs of the inexpensive model to bring its predictions closer to those of the detailed model ([3]). Engineering design uses metamodels to approximate expensive simulations ([31]). Multifidelity methods combine predictions from models with different costs and levels of detail ([17, 25]). These approaches motivate the local correction in Eq. (3). Here the correction uses observations from a single simulator under a fixed allowance. The rounded voxel responses limit the applicability of smooth trust-region convergence results.
Representing a library of unit cells
Precomputed families let designers interpolate between microstructures to select compatible geometries ([28]). Learning offers other ways to represent a library, for example by pooling information across microstructure classes ([33]), predicting properties of cells that combine periodic surfaces ([10]), or enforcing physical bounds in homogenisation ([18]). Our comparison holds the library fixed and tests the added contribution of learning when catalogue fits already support architecture ranking and sizing.
Other learned methods predict geometry directly or generate candidates in a continuous representation ([4, 35, 32, 27]). Separately, the way the catalogue is assembled can affect a design search ([21]). Diversity-based selection and task-aware sampling provide ways to improve that coverage ([7, 20]). Here both searches use the same catalogue so that table construction is the factor under test.
Spending simulations to meet a specification
Bayesian optimisation can use expected improvement to decide where to evaluate a design ([16]). Related work uses predictions to shortlist candidates for detailed verification ([11]) or to find designs likely to satisfy a property window ([15]). The utility of a surrogate also depends on the data and computation it needs ([2]). Our benchmark evaluates whether a design satisfies all target tolerances within the call allowance ([14]) and records the number of calls separately from the final error.
Fixed-budget ranking and selection allocates samples among competing alternatives ([9, 6]). Here a call also supplies a property measurement that can guide the sizing of the same architecture. Work on acquiring information for engineering design ([24, 8]) and materials discovery ([22]) motivates measuring what use observation contributes to later decisions. Shared tasks and baselines aid interpretation ([30]). We use the same verification and accounting rules for all searches, and matched component comparisons to isolate learning.
Design problem and benchmark
Architectures and simulation
A discrete architecture is denoted by . A design specifies the architecture and its continuous parameters , recorded to three decimal places. Table 1 lists the architectures and parameter bounds. Figure 1a shows example unit cells from the three systems. In the triply periodic minimal surface (TPMS) system, a network thresholds a single level-set field and a sheet thresholds its absolute value. A blend applies either construction to the field , where and are periodic fields scaled to unit standard deviation on the voxel grid. Each unordered pair has a fixed ordering and is the weight on the second field. For a strut architecture, the field is the distance to the nearest periodically repeated member axis. For all three systems, the density parameter sets the threshold through the rank of the sampled field values. The realised solid fraction can differ from because of voxelisation, ties and removal of isolated material.
| System | Discrete choice | Architectures | Density | Blend weight |
| TPMS | 8 families, network or sheet | 16 | 0.08–0.60 | |
| Strut | 8 periodic strut topologies | 8 | 0.06–0.50 | |
| Blend | 28 family pairs, network or sheet | 56 | 0.08–0.60 | 0.05–0.95 |
Table 1. Discrete architectures and continuous parameter bounds. TPMS denotes triply periodic minimal surface

Figure 1. Design space and target difficulty. a Gyroid sheet and network, three gyroid–Schwarz P network blends, Schwarz P network and octet lattice, drawn as smooth, closed isosurfaces of the underlying geometry evaluated on a grid at nominal density 0.30. The gyroid sheet drawing omits two small corner pieces (0.3% of its surface) connected to the body only through periodic cell faces; no other drawn cell has such pieces. Simulations use the voxel model; after connected-component filtering its realised density is 0.300 for the level-set examples and 0.354 for the octet. The blend weight on Schwarz P increases from 0.25 to 0.75 between the pure limits. b,c The 358 catalogue designs and 36 test targets in two response planes. Young’s modulus , Voigt bulk modulus and conductivity are dimensionless relative to the solid. Insets show TPMS target 2 of Figure 7, its 2% box and its ringed nearest catalogue design. This target’s retrieval error is closest to the median across targets. d Nearest-catalogue design error for every target: the largest of the three responses, in log units, with horizontal jitter within each system and the tolerance dashed. No catalogue design meets any target. TPMS denotes triply periodic minimal surface
The simulator estimates stiffness and conductivity on a voxel grid. The solid has unit Young’s modulus and conductivity and Poisson’s ratio 0.3. Let , and denote the effective stiffness, compliance and conductivity tensors, with and in Voigt notation, which writes each elasticity tensor as a matrix. The reported responses are , the Voigt bulk modulus , and axial conductivity . The moduli are in units of the solid Young’s modulus and the conductivity is in units of the solid conductivity.
The solver checks that the design has a continuous load and heat path and that its simulated responses are valid. The Supplementary Information specifies the geometry, solver and validity tests. The same simulator evaluates the catalogue, generates the principal target sets and verifies each returned design.
Catalogue and target sets
The shared offline catalogue contains 358 valid designs (128 TPMS, 80 strut and 150 blend). Candidate pure architectures were sampled at ten densities over each system’s range. Candidate blends were sampled at up to four density and weight combinations per pair and mode. Duplicate and invalid designs were removed. The resulting blend architectures have one to four examples each.
To generate the targets, the simulator evaluated designs sampled independently of the catalogue. A candidate reference had to be valid and its response had to lie at least 0.02 in the maximum absolute log-ratio distance from every catalogue response. The target therefore has a feasible reference under the simulator. The gap of 0.02 in log-ratio distance exceeds the 2% tolerance of about 0.00860 (Sect. 3.3), so catalogue retrieval alone fails. Figure 1b–Figure 1d shows the catalogue, the test targets and each target’s nearest-catalogue error. Retrieval alone thus scores zero by construction of the target filter. For a pure-architecture target (TPMS or strut), a search can match the reference by identifying its architecture and sizing its density parameter. Other architectures may also reach the target. The development split has 12 targets (3 TPMS, 3 strut and 6 blend), and the test split has 36 (9 TPMS, 9 strut and 18 blend). They share no reference design. The reference geometry is hidden from the search. The reference system is used for reporting, and a design from any system can meet a target.
Table 2 identifies which comparisons use each set. The planned learned-versus-catalogue comparison and the follow-up controls use the same 200 targets. Three further sets each have the test set’s system counts. The fresh draw uses a different reference-generator seed, the interpolated responses combine two reference responses in log space, and the responses solve the fresh reference designs on that grid. The test set and fresh draw are reachable on the search grid. Reachability on that grid is unknown for interpolated and responses. A separate confirmatory set contains 200 reachable targets from another generator seed (50 TPMS, 50 strut and 100 blend).
| Set | Targets | Reachable at | Role |
| Development | 12 | Yes | Select the learned configuration |
| Confirmatory | 200 | Yes | Planned table comparison and separate follow-up controls |
| Test | 36 | Yes | Benchmark search against retrieval and standard optimisers |
| Fresh draw | 36 | Yes | Repeat the benchmark on another draw and check resolution |
| Interpolated and | 36 each | Unknown | Test performance when reachability is uncertain |
Table 2. Target sets and their role in the evaluation
Scoring and call budget
For target properties and a valid simulated response , define the design error
Design error measures the largest absolute log-ratio between a simulated property and its target, with a cap of 1. A returned design that fails the validity checks scores 1. A run succeeds if the error of its returned design is at most . Each property ratio must then lie in , the rule referred to here as the 2% tolerance. A success is thus a match to the voxel model that also generated the targets. It is not a statement about a physical property (Sect. 6.9). We report success rate, mean error of the returned design, mean calls used and mean calls to success. Calls to success is the index of the first successful query and is set to 31 for a run with no such query, so its mean includes failures. The confirmatory decision uses success rate and design error, overall and on blends.
A call is charged per design in a batch, including invalid designs. Repeated queries are charged. The methods have unlimited access to the same catalogue and can use up to 30 simulator calls per target. The evaluation protocol independently re-solves the final returned design. This verification is separate from the search allowance and is applied to the retrieval control as well.
Each call can test another architecture or refine one that already has a valid observation. The searches use the same information and budget. They differ in how they rank and size architectures, how they adjust proposals after observing a response, and how many architectures they can test. The Supplementary Information states the allocation problem formally.
The voxel simulator stands in for an expensive solver, and the call budget is imposed to study allocation. Direct timing on the confirmatory target generation gives 0.179 seconds per design in batches over 871 designs and a median of 0.75 seconds for a single design over 12 solves.
Table inversion with simulator feedback
Precomputed response tables
The design catalogue stores simulated properties for existing designs. Each response table predicts three log properties at candidate dimensions within one architecture. The learned tables average the predictions of three feed-forward neural networks trained on the catalogue. The networks represent the same periodic field consistently whether it appears alone or in a blend.
The catalogue fits use the stored designs of each architecture. The pure-architecture fit interpolates piecewise linearly in log density. The blend fit estimates a plane over log density and blend weight. We call the resulting searches learned-table search and catalogue-table search. Both build their response tables before the first query and use the same grids, refinement rules and call budget. The Supplementary Information gives the network settings, grids and fitting rules.
Ranking and refinement
The search scores architectures with table predictions before testing them. Once an architecture has a valid observation, the search uses the observed mismatch to guide refinement within that architecture. Figure 2a–c shows the first batch, and panels d and e follow the later calls and verification.
First batch. Let . For an architecture with no valid observation for the current target, the first proposal minimises the predicted error on its available grid ,
Architectures are ordered by , with at most six from any system in the first batch of up to ten. Thus a promising architecture can be tested even if all its individual catalogue designs are far from the target.
Local refinement. In a queried architecture, let be the best observed design and its simulated log responses. Let contain the widths of the parameter ranges in Table 1 and denote the componentwise scaled offset. The corrected table is
Here is interpolated linearly for a pure architecture and bilinearly for a blend. Each row of gives the slope of the three residuals with respect to one scaled parameter. With one valid observation the slopes are zero. With more observations, we fit how the residual changes with the scaled design parameters. The fit gives more weight to designs closer to . The Supplementary Information gives the fit. The residual shifts the table to the simulated properties at , and the fitted slopes adjust that shift at nearby designs.
To choose the next refinement, the search evaluates the corrected table in a window centred at . It queries the candidate with the smallest predicted error . The window shrinks as the search collects valid observations. The search excludes catalogue designs, previously observed designs and a neighbourhood around each invalid query. An architecture with two invalid observations and no valid observation is dropped.
Later batches. After the first batch, the usual allocation is three refinements and two proposals in architectures without valid observations, subject to available candidates and calls. During this stage, a proposed refinement must have a predicted error below the best observed error for that architecture. An architecture also yields its place after three consecutive queries without improvement.

Figure 2. Table inversion and residual correction for blend target 1 in Figure 7, first seed. a Target, design space, catalogue and budget. b The ensemble supplies one response table per architecture. c Table scores and simulated design errors for the first batch of ten calls, with an architecture key (fcc denotes face-centred cubic). Four designs in this batch are invalid and still count against the budget. The continuation shows panels d,e
To improve the ranking of untested architectures in a system, the search can apply a common correction to their predictions. After it observes valid designs in at least three architectures, it checks whether a shared shift would improve predictions for that system. The Supplementary Information gives the rule for this shift.
Final refinement and stopping. Once the best observed error drops below twice the tolerance (), the search instead refines up to two architectures ordered by their observed error. Search stops after a batch containing a successful query, when no proposal remains or when the budget is exhausted. The search returns the observed or catalogue design with the lowest error. The Supplementary Information states the batch composition, the orderings and the tie rules in full.
Worked search trace
Figure 2 follows a search for a blend cell with three specified properties, in order axial Young’s modulus, Voigt bulk modulus and axial conductivity. The target values relative to the solid are approximately .

Figure 2 (PDF p. 7). The query trace and five proposals in the gyroid–Schwarz P network. Each valid simulated design updates the correction for its architecture. Invalid queries are drawn at the error cap. Call 26 first meets the tolerance, and the last batch brings the total to 27 calls, 11 invalid. The returned design is drawn as a smooth, closed isosurface of the underlying blended level-set field evaluated on a grid at its nominal density. Simulations and re-simulation use the voxel model of the same geometry.
The gyroid–Schwarz P network ranks third in the initial table ordering with a score of 0.0155. Its first simulated design has error 0.0415. Later refinements lower that error to 0.0131 at call 21 and 0.0060 at call 26. The returned design has and for the second field, Schwarz P. Re-simulation gives signed deviations of −1.37%, −0.98% and +0.03%, respectively.
Use of generative AI
Under the authors’ direction, Claude Code helped implement the software and assisted in interpreting the comparisons. The inverse-design method and all benchmark and control runs made zero calls to language models.
Experimental design
The planned comparison isolates the effect of table construction. The other comparisons test how feedback, architecture selection and call allocation affect search. Table 3 identifies what each comparison changes and where it is evaluated.
| Comparison | Change assessed | Main evidence |
| Learned / catalogue tables | Table construction under matched search and feedback | Planned comparison, confirmatory set |
| Corrected / uncorrected proposal | Residual use to choose the next design under matched decision rules | Test set and post-plan controls on the fresh and confirmatory sets |
| Degraded / catalogue / oracle tables | Response to larger changes in table quality | Post-plan controls, confirmatory set |
| Retrieval with and without pattern search | Charged local search within retrieved architectures | Test set |
| Catalogue-table search / retrieval with pattern search | Table-guided starts, refinement and allocation as a bundle | Test set |
| Broad / three-architecture search | Architecture allocation conditional on the table type | Test set and secondary confirmatory contrasts |
| Standard optimisers | Performance under alternative budgeted search policies | Test set and secondary confirmatory contrasts |
Table 3. Comparison arms, changes assessed and principal target sets
Confirmatory comparison
Before drawing the confirmatory targets, we fixed the target counts, generator seed (20261111), seven configurations, search seeds, primary contrast, endpoints and decision rule in a written analysis plan. The plan will be released with the study’s data and code.
The learned-table search, Bayesian optimisation and retrieval with pattern search use ten seeds (0–9). The four deterministic configurations were run with two seeds, which gave identical outcomes, and count once per target.
The primary contrast subtracts the catalogue-table outcome from the learned-table outcome. It uses success rate and design error, each overall and on blends. For each endpoint the declared rule detects a difference when its paired 95% target-bootstrap interval excludes zero. All four endpoints are reported together without multiplicity adjustment. Secondary contrasts include the standard optimisers, three-architecture catalogue search and calls. Target generation used 871 simulator calls outside the search budgets, plus one warm-up and 12 single-design solves for timing. No search receives reference designs.
Benchmark comparisons
Retrieval with pattern search ranks stored designs by their target error and picks the best catalogue design from each of the first three distinct architectures. It runs a coordinate pattern search within each chosen architecture, allotting up to ten calls to each. Initial steps are 0.04 in density and, for blends, 0.15 in weight. A sweep tests positive and negative coordinate moves, accepts the best improvement, and halves the steps if no move improves the error. The seed controls move order when the budget truncates a sweep. Retrieval alone, the retrieval control, returns the nearest stored design with no search calls. Random search draws 30 designs, choosing a system uniformly, then sampling its discrete choices and continuous parameters within their bounds. The common return and verification rules are given in Sect. 3.3.
The learned-table search uses tables from three neural networks and starts in up to ten architectures. Two candidate configurations were run on the 12 development targets. The first used a calibrated ensemble surrogate and trust-region refinement. It exceeded the preset compute-time limit, which stopped the run before a performance comparison. The second, a simplified variant of the first, is the reported method. It passed the development check below and is the only candidate run on the test targets. Neither candidate was run on the test targets before this selection.
The development check required at least two blend successes, at least five pure-system successes and mean design error at most 90% of the error of catalogue-table search (Sect. 5.3). The error criterion favoured configurations that performed better than the catalogue-table search on the development targets. Contrasts between the two on the test set can inherit this selection. The confirmatory targets were drawn after the configuration was fixed (Sect. 5.1).
We fixed the batch schedule in Sect. 4.2 and the step sizes of retrieval with pattern search before the tests. Each configuration was evaluated on 36 test targets three seeds (seeds 0, 1 and 2). The learned-table configuration was held fixed for the component comparisons. Variances and parameter sweeps evaluated on the same test targets are reported as attribution and sensitivity analyses. The additional sets assess the fixed configurations on other targets.
Three standard optimisers use the same catalogue and call allowance. These are our implementations of published algorithms. The catalogue-based starts and stopping rules described below are choices for this benchmark. Bracketing search orders architectures by catalogue-fitted table score and applies regula falsi with the Illinois update ([12]) to density, with at most five calls per architecture. It brackets the midpoint of the largest and smallest signed log residuals and fixes a blend’s weight at the table optimum. It ends refinement of an architecture when the absolute value of that midpoint is at most half the tolerance.
Nelder–Mead search [23] uses the same table-ranked starts, optimises density and blend weight where present, and allots ten calls per start with an initial simplex edge of 5% of each parameter range.
Bayesian optimisation fits a Gaussian process to predict properties with uncertainty. It updates that model using the simulated responses, then chooses the design with the largest expected improvement. It searches all architectures before refining within the chosen one. The Supplementary Information gives its prediction and selection rules. Comparator settings were fixed before test evaluation. We did not tune them on the development runs.
Component comparisons
The catalogue-table search keeps the search schedule and simulator feedback, replacing the learned predictions in both ranking and refinement. The categorical-encoding search replaces the shared field encoding (Sect. 4.1) with an 80-entry indicator with one nonzero entry for the architecture, weight, density and log density. It uses the same hidden widths, training schedule and number of members. Two role swaps use learned tables either for ranking and starting designs or for local refinement, with catalogue-fitted tables in the other role.
The proposal control changes how the next refinement design is chosen. The corrected search minimises the predicted error from the corrected table. The uncorrected-proposal control minimises the error predicted by the original table. Both use the same rule to set the candidate window and use corrected predictions to decide which architecture to refine and when to stop refining it. They make identical initial queries. Their observations can diverge once they propose different designs.
The no-residual control uses uncorrected proposals and makes two further changes. It omits correction from architecture selection and drops the system-level shift.
We run the uncorrected-proposal control with learned tables and with catalogue-fitted tables on the test set, the fresh draw and the confirmatory set, with the targets, seeds and budget of the corresponding corrected searches. The learned-table control on the test set belongs to the original component comparisons. The other control runs were added after the confirmatory plan and are not among its declared configurations. A further control replaces the local refinement with pattern search from learned-table starts. The pattern-search control starts from the same proposals as learned-table search. We report it separately from the comparison of corrected and uncorrected table proposals.
To examine call allocation, we also compare two searches that rank architectures by table inversion, start in three architectures and open no further architectures. One uses learned tables, and the other uses catalogue-fitted tables. A control seeded with the three catalogue designs used by retrieval with pattern search uses their known properties as initial observations and applies catalogue-table residual correction with up to ten calls per start. Finally, we vary the first-batch size (3, 6 and 15 versus 10) and the ensemble size (1 and 9 versus 3).
Paired analysis and offline diagnostic
The seed changes network initial weights, the move order of retrieval with pattern search, random-control draws and the Monte Carlo acquisition samples of Bayesian optimisation. Catalogue-table search, three-architecture catalogue search, bracketing search, Nelder–Mead search and retrieval control are deterministic. Their repeated seeds provide identical outcomes, and their seed-range entries are shown as a dash. For stochastic configurations we report the range of three seed-specific metric means. A difference larger than both ranges exceeds the spread observed across these seeds.
For paired comparisons, we first average over the seeds for each target. We then compare the two searches on the same targets. We report 95% percentile bootstrap intervals [13]. We resample targets within each system 20,000 times, keeping all seeds of each target together. Two-sided exact sign tests use the same target-level differences and omit ties. The Supplementary Information also reports Wilcoxon signed-rank tests [34] for design error. Intervals and tests are descriptive for these contrasts, with no adjustment for multiple comparisons.
A separate five-fold diagnostic holds out catalogue designs and ranks architectures for their simulated property vectors using tables fitted to the other folds. Recall at rank is the fraction of held-out designs whose source architecture appears in the first ranks. We report means and ranges over three model seeds and compare pooled and categorical encodings, catalogue-fitted tables and nearest-design retrieval. The diagnostic uses existing labels and spends no simulator calls. It measures recovery of a known source architecture on the catalogue grid.
Additional targets and grid-resolution checks
We evaluate the fixed configurations on three additional sets, each with 36 targets and three seeds. A fresh draw uses another seed of the same reference generator and the same catalogue-separation rule. An interpolated set uses log-space combinations of the responses of two reference designs from different architectures within one system. The responses use the fresh reference geometries solved at , while searches continue to query the simulator. Reachability on the search grid is unknown for the latter two sets. Generating these evaluation sets required 410 simulator calls at and 36 at , outside the per-target search allowance. No search receives the reference geometries or these generation responses as training data.
For learned-table search, catalogue-table search and retrieval with pattern search, we also solve the returned test and fresh-draw designs at without further search. On the test set, these responses are compared with the targets because the reference geometries remain hidden. On the fresh draw, both the returned geometry and the reference geometry are evaluated at . Property shifts are summarised over distinct returned designs. Success counts retain each target and seed. These checks measure a change of resolution, and convergence of the finer grid is untested.
Checks beyond the confirmatory plan
Two coverage analyses were added after the plan. One splits the confirmatory blend targets by the number of catalogue designs of the reference architecture. The other repeats learned-table search (seeds 0–2) and catalogue-table search on the confirmatory targets with a thinned catalogue. This catalogue keeps every second density of each pure architecture, starting from the lowest, and all blend designs, which leaves 259 of the 358 designs. Both table types are rebuilt from it.
The other controls test how sensitive the search is to table quality and how it performs with incomplete architecture coverage. We first repeated the 2,400 original learned-table and catalogue-table runs and obtained the same outcomes. The controls keep the 30-call budget and 2% stop rule. The degraded table uses one fit per system, shared by all its architectures. The oracle table uses extra simulator evaluations of individual architectures. The coverage check removes the catalogue designs for 14 randomly selected blend architectures. The Supplementary Information gives the construction costs and the details of these controls, which we planned after seeing the confirmatory results.
On the test set and fresh draw, the seven configurations also ran at 3% and 5% tolerance. Each search with early stopping used the corresponding tolerance to decide when to stop. The switch to refining only the two best architectures remains at twice the task tolerance, and bracketing search keeps its signed-residual threshold at half the tolerance. All other settings stay fixed. Retrieval with pattern search has no early stop, so its results are re-scored. The paired analyses of the smaller sets are post hoc, averaging seeds within target and resampling within system and, for pooled comparisons, within set.
Results
The planned learning comparison uses the 200-target set. The proposal and table-quality controls on those targets address separate questions about feedback and prediction quality. The remaining results compare search policies and examine sensitivity to target construction, tolerance and resolution.
Planned comparison detects no gain from learning
On the planned 200-target comparison, learned-table search succeeds in 1,687 of 2,000 runs with ten seeds per target. Deterministic catalogue-table search succeeds on 167 of 200 targets (Figure 3). Search and feedback are matched. Overall success differs by 0.0085 [−0.027, 0.045], and blend success by 0.023 [−0.044, 0.093]. Design-error differences are 0.00002 [−0.00104, 0.00099] overall and 0.00008 [−0.00195, 0.00195] on blends. All four declared intervals include zero under the decision rule in Sect. 5.1.
Figure 3. Declared comparison and exploratory contrasts. a Success on 200 reachable targets (50 TPMS, 50 strut, 100 blend). Bars average seeds, dots show individual seeds and black lines give 95% target-bootstrap intervals. Stochastic configurations use ten seeds, deterministic configurations count once. b,c Learned-table minus catalogue-table differences in success rate and design error. Filled circles denote all targets and open squares blends. Intervals resample targets 20,000 times within system and within set for pooled sets. The shaded confirmatory row uses the declared primary comparison. Smaller-set contrasts are post hoc and unadjusted for multiplicity. All searches use at most 30 simulator calls per target and zero language-model calls. TPMS denotes triply periodic minimal surface
The intervals measure variation across targets for the seeds and catalogue used in the experiment. The overall interval extends from a disadvantage of 2.7 percentage points to an advantage of 4.5. For blends, the interval extends from a disadvantage of 4.4 points to an advantage of 9.3. Smaller effects in either direction remain compatible with these data. The overall success sign test counts 18 targets better, 27 worse and 155 tied (). This result governs the claim about the learned model.
Correcting refinement proposals increases success
The follow-up controls on the 200-target set show that corrected proposals improve success for both types of table. Learned-table search meets 1,687 of 2,000 runs with corrected proposals and 1,330 with uncorrected proposals, a difference of 0.179 [0.142, 0.217]. Catalogue-table search meets 167 and 126 of the 200 targets, a difference of 0.205 [0.150, 0.260]. These controls address the proposal rule and were added after the confirmatory plan.
The 36-target test set shows when the proposals start to diverge. The learned-table search and the uncorrected-proposal control make the same first ten queries for every run. On blend targets they each meet ten runs in that first batch. By the end of the search they meet 32 and 17 blend runs, respectively (Figure 4a,Figure 4b). Across all systems the corrected proposals meet 84 runs, compared with 65 under the uncorrected proposal rule. Twenty runs succeed only with correction, and one succeeds only with the uncorrected proposal. The mean error difference is −0.00796 with interval [−0.01338, −0.00355], and the success-rate difference is 0.176 with interval [0.093, 0.278]. Both differences exceed the seed ranges. The control that removes all uses of the residual meets the same 65 runs as the uncorrected-proposal control. It issues the same queries as that control in 73 of the 108 runs and returns the same design in 100, so the further uses of the residual change some queries and no success outcome.
Figure 4. Search progress on the 54 blend runs. a Share of runs met by each simulator call, with pooled-seed curves thick and single-seed curves thin. b Median best design error, with the last value carried forward after stopping. The vertical marker ends the first batch of ten calls. Bars to the right of call 30 give the interquartile range and median for every configuration, and the horizontal threshold is , the 2% tolerance. These bars represent call 30. Line styles and markers identify configurations in greyscale. Learned-table search and the uncorrected-proposal control have identical first-batch traces.
The proposal controls also improve success for catalogue fits on the test set and both table types on the fresh draw (Table S16 in the Supplementary Information). With catalogue-fitted tables, corrected proposals meet 78 test runs and uncorrected proposals meet 57, a success-rate difference of 0.194 with interval [0.083, 0.333]. On the fresh draw the corrected and uncorrected counts are 94 and 73 with learned tables and 87 and 69 with catalogue tables. Averaged over seeds within each target, no target in these six comparisons has a higher success rate with uncorrected proposals. The control runs on the fresh draw and the confirmatory set were added after the confirmatory plan, so these contrasts are not declared endpoints.
| Tables, targets | Runs met | Success difference | 95% interval | Targets better / worse () | Error difference | 95% interval |
| Test set (36 targets) | ||||||
| Learned tables, all | 84/108 vs 65/108 | +0.176 | [+0.093, +0.278] | 11 / 0 (<0.001) | −0.00796 | [−0.01338, −0.00355] |
| Learned tables, blend | 32/54 vs 17/54 | +0.278 | [+0.130, +0.444] | 9 / 0 (0.004) | −0.01411 | [−0.02447, −0.00557] |
| Catalogue tables, all | 78/108 vs 57/108 | +0.194 | [+0.083, +0.333] | 7 / 0 (0.016) | −0.01885 | [−0.03589, −0.00593] |
| Catalogue tables, blend | 24/54 vs 12/54 | +0.222 | [+0.056, +0.444] | 4 / 0 (0.125) | −0.03436 | [−0.06829, −0.00868] |
| Fresh draw (36 targets) | ||||||
| Learned tables, all | 94/108 vs 73/108 | +0.194 | [+0.102, +0.296] | 11 / 0 (<0.001) | −0.00428 | [−0.00727, −0.00190] |
| Learned tables, blend | 43/54 vs 25/54 | +0.333 | [+0.185, +0.500] | 10 / 0 (0.002) | −0.00762 | [−0.01339, −0.00291] |
| Catalogue tables, all | 87/108 vs 69/108 | +0.167 | [+0.056, +0.306] | 6 / 0 (0.031) | −0.00423 | [−0.00751, −0.00170] |
| Catalogue tables, blend | 36/54 vs 24/54 | +0.222 | [+0.056, +0.444] | 4 / 0 (0.125) | −0.00756 | [−0.01391, −0.00261] |
| Confirmatory set (200 targets) | ||||||
| Learned tables, all | 1687/2000 vs 1330/2000 | +0.179 | [+0.142, +0.217] | 66 / 0 (<0.001) | −0.00722 | [−0.00998, −0.00491] |
| Learned tables, blend | 703/1000 vs 397/1000 | +0.306 | [+0.243, +0.369] | 59 / 0 (<0.001) | −0.01242 | [−0.01756, −0.00821] |
| Catalogue tables, all | 167/200 vs 126/200 | +0.205 | [+0.150, +0.260] | 41 / 0 (<0.001) | −0.00861 | [−0.01179, −0.00592] |
| Catalogue tables, blend | 68/100 vs 37/100 | +0.310 | [+0.220, +0.400] | 31 / 0 (<0.001) | −0.01424 | [−0.02020, −0.00944] |
Table S16. Table S16: Corrected minus uncorrected refinement proposal for both table types. The control keeps every decision rule of the search and takes the queried design from the uncorrected table in the same window. Runs met are given as corrected vs uncorrected. Differences in success rate and design error average seeds within target; the 95% intervals resample targets 20,000 times within system. The sign test counts targets better / worse for the corrected proposal, with its two-sided value in parentheses. Learned tables use three seeds on the 36-target sets and ten seeds on the confirmatory set; catalogue tables are deterministic and count once per target on the confirmatory set. The learned-table rows of the test set repeat the contrast of Table S3 and Table S4. All other uncorrected-proposal runs were added after the confirmatory plan and are not among its declared configurations. All runs use at most 30 simulator calls per target and zero language-model calls.
Table S3: Paired design-error contrasts over all test targets and over blends. Differences subtract the mean of from that of . Exceeds both seed ranges indicates that the absolute difference exceeds both seed ranges. The 95% intervals bootstrap paired target means. Sign and Wilcoxon signed-rank tests ([34]) use paired target means and omit ties. Boundary intervals carry no information about new targets.
| Contrast () | Difference | 95% interval | Targets better / worse / tied | Sign / Wilcoxon |
| Learned-table search − retrieval with pattern search | −0.02625 | [−0.03751, −0.01697] | 32 / 0 / 4 | <0.001 / <0.001 |
| All targets have runs met 84 versus 23, with 61 versus 0 met by one variant only. Seed ranges are 0.00065 and 0.00180. The difference exceeds both seed ranges. | ||||
| Learned-table search − retrieval with pattern search | −0.03443 | [−0.05509, −0.01820] | 18 / 0 / 0 | <0.001 / <0.001 |
| Blend targets have runs met 32 versus 2, with 30 versus 0 met by one variant only. Seed ranges are 0.00098 and 0.00357. The difference exceeds both seed ranges. | ||||
| Learned-table search − catalogue-table search | −0.00161 | [−0.00605, +0.00122] | 13 / 11 / 12 | 0.839 / 0.900 |
| All targets have runs met 84 versus 78, with 9 versus 3 met by one variant only. Seed ranges are 0.00065 and 0.00000. The difference exceeds both seed ranges. | ||||
| Learned-table search − catalogue-table search | −0.00344 | [−0.01212, +0.00183] | 10 / 7 / 1 | 0.629 / 0.747 |
| Blend targets have runs met 32 versus 24, with 9 versus 1 met by one variant only. Seed ranges are 0.00098 and 0.00000. The difference exceeds both seed ranges. | ||||
| Learned-table search − categorical-encoding search | −0.00414 | [−0.00996, −0.00023] | 20 / 7 / 9 | 0.019 / 0.032 |
| All targets have runs met 84 versus 79, with 10 versus 5 met by one variant only. Seed ranges are 0.00065 and 0.00168. The difference exceeds both seed ranges. | ||||
| Learned-table search − categorical-encoding search | −0.00857 | [−0.02044, −0.00096] | 15 / 3 / 0 | 0.008 / 0.006 |
| Blend targets have runs met 32 versus 25, with 10 versus 3 met by one variant only. Seed ranges are 0.00098 and 0.00350. The difference exceeds both seed ranges. | ||||
| Categorical-encoding search − catalogue-table search | +0.00253 | [−0.00132, +0.00821] | 10 / 16 / 10 | 0.327 / 0.165 |
| All targets have runs met 79 versus 78, with 8 versus 7 met by one variant only. Seed ranges are 0.00168 and 0.00000. The difference exceeds both seed ranges. | ||||
| Categorical-encoding search − catalogue-table search | +0.00513 | [−0.00268, +0.01644] | 7 / 11 / 0 | 0.481 / 0.154 |
| Blend targets have runs met 25 versus 24, with 8 versus 7 met by one variant only. Seed ranges are 0.00350 and 0.00000. The difference exceeds both seed ranges. | ||||
| Learned tables for ranking only − catalogue-table search | −0.00132 | [−0.00684, +0.00246] | 13 / 11 / 12 | 0.839 / 0.790 |
| All targets have runs met 84 versus 78, with 8 versus 2 met by one variant only. Seed ranges are 0.00039 and 0.00000. The difference exceeds both seed ranges. | ||||
| Learned tables for ranking only − catalogue-table search | −0.00225 | [−0.01325, +0.00536] | 9 / 8 / 1 | 1.000 / 1.000 |
| Blend targets have runs met 30 versus 24, with 8 versus 2 met by one variant only. Seed ranges are 0.00085 and 0.00000. The difference exceeds both seed ranges. | ||||
| Learned tables for refinement only − catalogue-table search | +0.00076 | [−0.00025, +0.00211] | 5 / 10 / 21 | 0.302 / 0.188 |
| All targets have runs met 80 versus 78, with 4 versus 2 met by one variant only. Seed ranges are 0.00100 and 0.00000. The difference does not exceed both seed ranges. | ||||
| Learned tables for refinement only − catalogue-table search | +0.00136 | [−0.00067, +0.00405] | 5 / 8 / 5 | 0.581 / 0.340 |
| Blend targets have runs met 26 versus 24, with 4 versus 2 met by one variant only. Seed ranges are 0.00208 and 0.00000. The difference does not exceed both seed ranges. | ||||
| Learned-table search − uncorrected-proposal control | −0.00796 | [−0.01338, −0.00355] | 20 / 0 / 16 | <0.001 / <0.001 |
| All targets have runs met 84 versus 65, with 20 versus 1 met by one variant only. Seed ranges are 0.00065 and 0.00194. The difference exceeds both seed ranges. | ||||
| Learned-table search − uncorrected-proposal control | −0.01411 | [−0.02447, −0.00557] | 16 / 0 / 2 | <0.001 / <0.001 |
| Blend targets have runs met 32 versus 17, with 16 versus 1 met by one variant only. Seed ranges are 0.00098 and 0.00366. The difference exceeds both seed ranges. | ||||
| Learned-table search − no-residual control | −0.00736 | [−0.01263, −0.00318] | 20 / 0 / 16 | <0.001 / <0.001 |
| All targets have runs met 84 versus 65, with 20 versus 1 met by one variant only. Seed ranges are 0.00065 and 0.00249. The difference exceeds both seed ranges. | ||||
| Learned-table search − no-residual control | −0.01291 | [−0.02304, −0.00488] | 16 / 0 / 2 | <0.001 / <0.001 |
| Blend targets have runs met 32 versus 17, with 16 versus 1 met by one variant only. Seed ranges are 0.00098 and 0.00477. The difference exceeds both seed ranges. | ||||
| Learned-table search − pattern-search refinement | −0.00991 | [−0.01644, −0.00466] | 20 / 0 / 16 | <0.001 / <0.001 |
| All targets have runs met 84 versus 59, with 25 versus 0 met by one variant only. Seed ranges are 0.00065 and 0.00476. The difference exceeds both seed ranges. | ||||
| Learned-table search − pattern-search refinement | −0.01825 | [−0.03095, −0.00782] | 16 / 0 / 2 | <0.001 / <0.001 |
| Blend targets have runs met 32 versus 11, with 21 versus 0 met by one variant only. Seed ranges are 0.00098 and 0.00749. The difference exceeds both seed ranges. | ||||
| Learned-table search − three architectures with learned tables | −0.00738 | [−0.01240, −0.00331] | 23 / 3 / 10 | <0.001 / <0.001 |
| All targets have runs met 84 versus 71, with 17 versus 4 met by one variant only. Seed ranges are 0.00065 and 0.00408. The difference exceeds both seed ranges. | ||||
| Learned-table search − three architectures with learned tables | −0.01034 | [−0.01964, −0.00321] | 14 / 2 / 2 | 0.004 / 0.002 |
| Blend targets have runs met 32 versus 28, with 7 versus 3 met by one variant only. Seed ranges are 0.00098 and 0.01252. The difference does not exceed both seed ranges. | ||||
| Contrast () | Difference | 95% interval | Targets better / worse / tied | Sign / Wilcoxon |
| Learned-table search − three-architecture catalogue search | −0.00371 | [−0.00903, +0.00039] | 15 / 9 / 12 | 0.307 / 0.317 |
| All targets have runs met 84 versus 84, with 5 versus 5 met by one variant only. Seed ranges are 0.00065 and 0.00000. The difference exceeds both seed ranges. | ||||
| Learned-table search − three-architecture catalogue search | −0.00733 | [−0.01754, +0.00061] | 11 / 6 / 1 | 0.332 / 0.306 |
| Blend targets have runs met 32 versus 30, with 5 versus 3 met by one variant only. Seed ranges are 0.00098 and 0.00000. The difference exceeds both seed ranges. | ||||
| Three-architecture catalogue search − catalogue-table search | +0.00210 | [−0.00059, +0.00598] | 3 / 5 / 28 | 0.727 / 0.461 |
| All targets have runs met 84 versus 78, with 6 versus 0 met by one variant only. Seed ranges are 0.00000 and 0.00000. The difference exceeds both seed ranges. | ||||
| Three-architecture catalogue search − catalogue-table search | +0.00388 | [−0.00143, +0.01165] | 3 / 3 / 12 | 1.000 / 0.688 |
| Blend targets have runs met 30 versus 24, with 6 versus 0 met by one variant only. Seed ranges are 0.00000 and 0.00000. The difference exceeds both seed ranges. | ||||
| First batch of 3 − Learned-table search | +0.00046 | [−0.00032, +0.00138] | 4 / 10 / 22 | 0.180 / 0.104 |
| All targets have runs met 83 versus 84, with 2 versus 3 met by one variant only. Seed ranges are 0.00063 and 0.00065. The difference does not exceed both seed ranges. | ||||
| First batch of 3 − Learned-table search | +0.00066 | [−0.00090, +0.00245] | 4 / 7 / 7 | 0.549 / 0.320 |
| Blend targets have runs met 32 versus 32, with 2 versus 2 met by one variant only. Seed ranges are 0.00177 and 0.00098. The difference does not exceed both seed ranges. | ||||
| First batch of 6 − Learned-table search | −0.00014 | [−0.00078, +0.00041] | 6 / 5 / 25 | 1.000 / 1.000 |
| All targets have runs met 87 versus 84, with 3 versus 0 met by one variant only. Seed ranges are 0.00193 and 0.00065. The difference does not exceed both seed ranges. | ||||
| First batch of 6 − Learned-table search | −0.00051 | [−0.00173, +0.00057] | 6 / 3 / 9 | 0.508 / 0.496 |
| Blend targets have runs met 35 versus 32, with 3 versus 0 met by one variant only. Seed ranges are 0.00311 and 0.00098. The difference does not exceed both seed ranges. | ||||
| First batch of 15 − Learned-table search | +0.00085 | [+0.00037, +0.00143] | 0 / 10 / 26 | 0.002 / 0.002 |
| All targets have runs met 79 versus 84, with 0 versus 5 met by one variant only. Seed ranges are 0.00113 and 0.00065. The difference does not exceed both seed ranges. | ||||
| First batch of 15 − Learned-table search | +0.00169 | [+0.00074, +0.00284] | 0 / 10 / 8 | 0.002 / 0.002 |
| Blend targets have runs met 27 versus 32, with 0 versus 5 met by one variant only. Seed ranges are 0.00336 and 0.00098. The difference does not exceed both seed ranges. | ||||
| 1 MLP − Learned-table search | +0.00088 | [−0.00044, +0.00250] | 11 / 14 / 11 | 0.690 / 0.791 |
| All targets have runs met 80 versus 84, with 5 versus 9 met by one variant only. Seed ranges are 0.00292 and 0.00065. The difference does not exceed both seed ranges. | ||||
| 1 MLP − Learned-table search | +0.00219 | [−0.00028, +0.00533] | 7 / 10 / 1 | 0.629 / 0.459 |
| Blend targets have runs met 28 versus 32, with 4 versus 8 met by one variant only. Seed ranges are 0.00609 and 0.00098. The difference does not exceed both seed ranges. | ||||
| 9 MLPs − Learned-table search | +0.00061 | [−0.00115, +0.00331] | 13 / 10 / 13 | 0.678 / 0.482 |
| All targets have runs met 82 versus 84, with 2 versus 4 met by one variant only. Seed ranges are 0.00058 and 0.00065. The difference does not exceed both seed ranges. | ||||
| 9 MLPs − Learned-table search | +0.00129 | [−0.00203, +0.00663] | 10 / 7 / 1 | 0.629 / 0.459 |
| Blend targets have runs met 29 versus 32, with 1 versus 4 met by one variant only. Seed ranges are 0.00177 and 0.00098. The difference does not exceed both seed ranges. | ||||
| Pattern-search starts with corrected refinement − retrieval with pattern search | −0.01215 | [−0.01829, −0.00722] | 26 / 2 / 8 | <0.001 / <0.001 |
| All targets have runs met 45 versus 23, with 22 versus 0 met by one variant only. Seed ranges are 0.00000 and 0.00180. The difference exceeds both seed ranges. | ||||
| Pattern-search starts with corrected refinement − retrieval with pattern search | −0.01885 | [−0.03044, −0.00964] | 17 / 0 / 1 | <0.001 / <0.001 |
| Blend targets have runs met 18 versus 2, with 16 versus 0 met by one variant only. Seed ranges are 0.00000 and 0.00357. The difference exceeds both seed ranges. | ||||
| Three-architecture catalogue search − pattern-search starts with corrected refinement | −0.01039 | [−0.02120, −0.00086] | 18 / 11 / 7 | 0.265 / 0.024 |
| All targets have runs met 84 versus 45, with 42 versus 3 met by one variant only. Seed ranges are 0.00000 and 0.00000. The difference exceeds both seed ranges. | ||||
| Three-architecture catalogue search − pattern-search starts with corrected refinement | −0.00825 | [−0.02908, +0.00962] | 9 / 9 / 0 | 1.000 / 0.766 |
| Blend targets have runs met 30 versus 18, with 15 versus 3 met by one variant only. Seed ranges are 0.00000 and 0.00000. The difference exceeds both seed ranges. |
Table S3. Table S3 (continued)
| Contrast () | Difference | 95% interval | Targets better / worse / tied | Sign |
| Learned-table search − retrieval with pattern search | +0.565 | [+0.417, +0.704] | 25 / 0 / 11 | <0.001 |
| All targets have runs met 84 versus 23, with 61 versus 0 met by one variant only. Seed ranges are 0.139 and 0.028. The difference exceeds both seed ranges. | ||||
| Learned-table search − retrieval with pattern search | +0.556 | [+0.370, +0.741] | 14 / 0 / 4 | <0.001 |
| Blend targets have runs met 32 versus 2, with 30 versus 0 met by one variant only. Seed ranges are 0.222 and 0.056. The difference exceeds both seed ranges. | ||||
| Learned-table search − catalogue-table search | +0.056 | [−0.019, +0.139] | 6 / 2 / 28 | 0.289 |
| All targets have runs met 84 versus 78, with 9 versus 3 met by one variant only. Seed ranges are 0.139 and 0.000. The difference does not exceed both seed ranges. | ||||
| Learned-table search − catalogue-table search | +0.148 | [+0.019, +0.296] | 6 / 1 / 11 | 0.125 |
| Blend targets have runs met 32 versus 24, with 9 versus 1 met by one variant only. Seed ranges are 0.222 and 0.000. The difference does not exceed both seed ranges. | ||||
| Learned-table search − categorical-encoding search | +0.046 | [−0.037, +0.120] | 9 / 3 / 24 | 0.146 |
| All targets have runs met 84 versus 79, with 10 versus 5 met by one variant only. Seed ranges are 0.139 and 0.167. The difference does not exceed both seed ranges. | ||||
| Learned-table search − categorical-encoding search | +0.130 | [−0.019, +0.259] | 9 / 2 / 7 | 0.065 |
| Blend targets have runs met 32 versus 25, with 10 versus 3 met by one variant only. Seed ranges are 0.222 and 0.333. The difference does not exceed both seed ranges. | ||||
| Categorical-encoding search − catalogue-table search | +0.009 | [−0.083, +0.102] | 5 / 5 / 26 | 1.000 |
| All targets have runs met 79 versus 78, with 8 versus 7 met by one variant only. Seed ranges are 0.167 and 0.000. The difference does not exceed both seed ranges. | ||||
| Categorical-encoding search − catalogue-table search | +0.019 | [−0.167, +0.222] | 5 / 5 / 8 | 1.000 |
| Blend targets have runs met 25 versus 24, with 8 versus 7 met by one variant only. Seed ranges are 0.333 and 0.000. The difference does not exceed both seed ranges. | ||||
| Learned tables for ranking only − catalogue-table search | +0.056 | [−0.019, +0.139] | 4 / 1 / 31 | 0.375 |
| All targets have runs met 84 versus 78, with 8 versus 2 met by one variant only. Seed ranges are 0.083 and 0.000. The difference does not exceed both seed ranges. | ||||
| Learned tables for ranking only − catalogue-table search | +0.111 | [−0.037, +0.278] | 4 / 1 / 13 | 0.375 |
| Blend targets have runs met 30 versus 24, with 8 versus 2 met by one variant only. Seed ranges are 0.167 and 0.000. The difference does not exceed both seed ranges. | ||||
| Learned tables for refinement − catalogue-table search | +0.019 | [−0.037, +0.074] | 3 / 1 / 32 | 0.625 |
| All targets have runs met 80 versus 78, with 4 versus 2 met by one variant only. Seed ranges are 0.111 and 0.000. The difference does not exceed both seed ranges. | ||||
| Learned tables for refinement only − catalogue-table search | +0.074 | [−0.074, +0.148] | 3 / 1 / 14 | 0.625 |
| Blend targets have runs met 26 versus 24, with 4 versus 2 met by one variant only. Seed ranges are 0.222 and 0.000. The difference does not exceed both seed ranges. | ||||
| Learned-table search − uncorrected-proposal control | +0.176 | [+0.093, +0.278] | 11 / 0 / 25 | <0.001 |
| All targets have runs met 84 versus 65, with 20 versus 1 met by one variant only. Seed ranges are 0.139 and 0.028. The difference exceeds both seed ranges. | ||||
| Learned-table search − uncorrected-proposal control | +0.278 | [+0.130, +0.444] | 9 / 0 / 9 | 0.004 |
| Blend targets have runs met 32 versus 17, with 16 versus 1 met by one variant only. Seed ranges are 0.222 and 0.056. The difference exceeds both seed ranges. | ||||
| Learned-table search − no-residual control | +0.176 | [+0.093, +0.278] | 11 / 0 / 25 | <0.001 |
| All targets have runs met 84 versus 65, with 20 versus 1 met by one variant only. Seed ranges are 0.139 and 0.028. The difference exceeds both seed ranges. | ||||
| Learned-table search − no-residual control | +0.278 | [+0.130, +0.444] | 9 / 0 / 9 | 0.004 |
| Blend targets have runs met 32 versus 17, with 16 versus 1 met by one variant only. Seed ranges are 0.222 and 0.056. The difference exceeds both seed ranges. | ||||
| Learned-table search − pattern-search refinement | +0.148 | [+0.148, +0.148] | 16 / 0 / 20 | <0.001 |
| All targets have runs met 84 versus 59, with 25 versus 0 met by one variant only. Seed ranges are 0.139 and 0.167. The difference exceeds both seed ranges. | ||||
| Learned-table search − pattern-search refinement | +0.389 | [+0.241, +0.537] | 13 / 0 / 5 | <0.001 |
| Blend targets have runs met 32 versus 11, with 21 versus 0 met by one variant only. Seed ranges are 0.222 and 0.278. The difference exceeds both seed ranges. | ||||
| Learned-table search − three heuristics with learned tables | +0.120 | [+0.037, +0.204] | 10 / 2 / 24 | 0.039 |
| All targets have runs met 84 versus 71, with 17 versus 4 met by one variant only. Seed ranges are 0.139 and 0.028. The difference does not exceed both seed ranges. | ||||
| Learned-table search − three heuristics with learned tables | +0.074 | [−0.019, +0.185] | 4 / 1 / 13 | 0.375 |
| Blend targets have runs met 32 versus 28, with 7 versus 3 met by one variant only. Seed ranges are 0.222 and 0.056. The difference does not exceed both seed ranges. | ||||
| Contrast () | Difference | 95% interval | Targets better / worse / tied | Sign |
| Learned-table search − three-architecture catalogue search | 0.000 | [−0.074, +0.074] | 4 / 3 / 29 | 1.000 |
| All targets have runs met 84 versus 84, with 5 versus 5 met by one variant only. Seed ranges are 0.139 and 0.000. The difference does not exceed both seed ranges. | ||||
| Learned-table search − three-architecture catalogue search | +0.037 | [−0.093, +0.167] | 4 / 2 / 12 | 0.688 |
| Blend targets have runs met 32 versus 30, with 5 versus 3 met by one variant only. Seed ranges are 0.222 and 0.000. The difference does not exceed both seed ranges. | ||||
| Three-architecture catalogue search − catalogue-table search | +0.056 | [0.000, +0.139] | 2 / 0 / 34 | 0.500 |
| All targets have runs met 84 versus 78, with 6 versus 0 met by one variant only. Seed ranges are 0.000 and 0.000. The difference exceeds both seed ranges. | ||||
| Three-architecture catalogue search − catalogue-table search | +0.111 | [0.000, +0.278] | 2 / 0 / 16 | 0.500 |
| Blend targets have runs met 30 versus 24, with 6 versus 0 met by one variant only. Seed ranges are 0.000 and 0.000. The difference exceeds both seed ranges. | ||||
| First batch of 3 − Learned-table search | −0.009 | [−0.037, +0.019] | 1 / 2 / 33 | 1.000 |
| All targets have runs met 83 versus 84, with 2 versus 3 met by one variant only. Seed ranges are 0.111 and 0.139. The difference does not exceed both seed ranges. | ||||
| First batch of 3 − Learned-table search | 0.000 | [−0.056, +0.056] | 1 / 1 / 16 | 1.000 |
| Blend targets have runs met 32 versus 32, with 2 versus 2 met by one variant only. Seed ranges are 0.167 and 0.222. The difference does not exceed both seed ranges. | ||||
| First batch of 6 − Learned-table search | +0.028 | [0.000, +0.056] | 3 / 0 / 33 | 0.250 |
| All targets have runs met 87 versus 84, with 3 versus 0 met by one variant only. Seed ranges are 0.139 and 0.139. The difference does not exceed both seed ranges. | ||||
| First batch of 6 − Learned-table search | +0.056 | [0.000, +0.111] | 3 / 0 / 15 | 0.250 |
| Blend targets have runs met 35 versus 32, with 3 versus 0 met by one variant only. Seed ranges are 0.222 and 0.222. The difference does not exceed both seed ranges. | ||||
| First batch of 15 − Learned-table search | −0.046 | [−0.093, −0.009] | 0 / 4 / 32 | 0.125 |
| All targets have runs met 79 versus 84, with 0 versus 5 met by one variant only. Seed ranges are 0.083 and 0.139. The difference does not exceed both seed ranges. | ||||
| First batch of 15 − Learned-table search | −0.093 | [−0.185, −0.019] | 0 / 4 / 14 | 0.125 |
| Blend targets have runs met 27 versus 32, with 0 versus 5 met by one variant only. Seed ranges are 0.111 and 0.222. The difference does not exceed both seed ranges. | ||||
| 1 MLP − Learned-table search | −0.037 | [−0.074, 0.000] | 1 / 5 / 30 | 0.219 |
| All targets have runs met 80 versus 84, with 5 versus 9 met by one variant only. Seed ranges are 0.083 and 0.139. The difference does not exceed both seed ranges. | ||||
| 1 MLP − Learned-table search | −0.074 | [−0.148, 0.000] | 1 / 5 / 12 | 0.219 |
| Blend targets have runs met 28 versus 32, with 4 versus 8 met by one variant only. Seed ranges are 0.167 and 0.222. The difference does not exceed both seed ranges. | ||||
| 9 MLPs − Learned-table search | −0.019 | [−0.056, +0.009] | 1 / 3 / 32 | 0.625 |
| All targets have runs met 82 versus 84, with 2 versus 4 met by one variant only. Seed ranges are 0.056 and 0.139. The difference does not exceed both seed ranges. | ||||
| 9 MLPs − Learned-table search | −0.056 | [−0.111, 0.000] | 0 / 3 / 15 | 0.250 |
| Blend targets have runs met 29 versus 32, with 1 versus 4 met by one variant only. Seed ranges are 0.056 and 0.222. The difference does not exceed both seed ranges. | ||||
| Pattern-search starts with corrected refinement − retrieval with pattern search | +0.204 | [+0.093, +0.333] | 8 / 0 / 28 | 0.008 |
| All targets have runs met 45 versus 23, with 22 versus 0 met by one variant only. Seed ranges are 0.000 and 0.028. The difference exceeds both seed ranges. | ||||
| Pattern-search starts with corrected refinement − retrieval with pattern search | +0.296 | [+0.111, +0.500] | 6 / 0 / 12 | 0.031 |
| Blend targets have runs met 18 versus 2, with 16 versus 0 met by one variant only. Seed ranges are 0.000 and 0.056. The difference exceeds both seed ranges. | ||||
| Three-architecture catalogue search − pattern-search starts with corrected refinement | +0.361 | [+0.194, +0.528] | 14 / 1 / 21 | <0.001 |
| All targets have runs met 84 versus 45, with 42 versus 3 met by one variant only. Seed ranges are 0.000 and 0.000. The difference exceeds both seed ranges. | ||||
| Three-architecture catalogue search − pattern-search starts with corrected refinement | +0.222 | [0.000, +0.444] | 5 / 1 / 12 | 0.219 |
| Blend targets have runs met 30 versus 18, with 15 versus 3 met by one variant only. Seed ranges are 0.000 and 0.000. The difference exceeds both seed ranges. |
Table S4. Paired success-rate contrasts over all test targets and over blends. Differences subtract the mean of from that of . Exceeds both seed ranges indicates that the absolute difference exceeds both seed ranges. The 95% intervals bootstrap paired target means. The exact sign test uses paired target means and omits ties. Boundary intervals carry no information about new targets.
The uncorrected control makes smaller changes to its designs. On the test set, 50% of its later queries in a given architecture stay within 0.003 in density and, for blends, 0.01 in weight of the first query in that architecture. The corresponding share for corrected designs is 21%. Measuring distance as the largest parameter change relative to its range, the median step from the best observed design is 0.007 for the control and 0.021 for the corrected search. The control therefore often samples again close to the optimum of the uncorrected table, and the contrast measures corrected proposals against that behaviour.
The contrast identifies an effect of using the residual to choose a refinement design under these search rules. The subsequent simulator observations need not agree after the first changed proposal. On the catalogue starts used by retrieval with pattern search, applying corrected table refinement meets 45 runs, compared with 23 for the retrieval with pattern search. The further pattern-search control from learned-table starts meets 59 runs, providing a second comparison with a coordinate search.
On the worked example in Fig. 2, catalogue-table search meets the target in the same architecture at call 26, and three-architecture catalogue search succeeds at call 7. Retrieval with pattern search uses 22 calls and returns its best catalogue design at error 0.1505.
Search responds to large changes in table quality
Success responds to both a poorer and a better response table (Figure 5, Table S18 and Table S19 in the Supplementary Information). Relative to catalogue tables, the degraded table lowers overall success from 0.835 to 0.360, a difference of −0.475 [−0.545, −0.405], while the oracle table raises it to 0.965, a difference of 0.130 [0.085, 0.180]. On blends the differences are −0.490 and 0.270, respectively. The learned tables predict blend reference responses more accurately than catalogue tables (median maximum log error 0.073 against 0.097), but this improvement produces no detected success-rate gain. The larger changes to the degraded and oracle tables do affect success. The controls establish sensitivity to large differences in prediction quality.
Figure 5. Table-quality controls and held-out architectures on 200 confirmatory targets. a Success by system and overall; hatching marks held-out architectures. Bars average seeds, dots show seeds and black lines give 95% target-bootstrap intervals. b Paired success differences for all targets (filled circles) and blends (open squares). c Blend success against median table error at reference designs; the dashed line marks the 2% tolerance. Search rules and the simulator are unchanged, with at most 30 calls and zero language-model calls. Learned arms use seeds 0–2; Figure 3 uses ten. Only the oracle uses extra simulator data. These post-plan controls are not declared confirmatory endpoints. Intervals use 20,000 target resamples without multiplicity adjustment. TPMS denotes triply periodic minimal surface
| System | Met / runs | Success [95% interval] | Design error | Calls to success | Simulator calls |
| Degraded table | |||||
| All | 72/200 | 0.360 [0.295, 0.420] | 0.02054 | 25.98 | 26.32 |
| TPMS | 27/50 | 0.540 [0.400, 0.680] | 0.01254 | 23.40 | 24.32 |
| Strut | 26/50 | 0.520 [0.380, 0.660] | 0.01668 | 23.50 | 24.70 |
| Blend | 19/100 | 0.190 [0.120, 0.270] | 0.02647 | 28.52 | 28.13 |
| Catalogue tables, full catalogue | |||||
| All | 167/200 | 0.835 [0.785, 0.880] | 0.00667 | 10.61 | 15.43 |
| System | Met / runs | Success [95% interval] | Design error | Calls to success | Simulator calls |
| TPMS | 49/50 | 0.980 [0.940, 1.000] | 0.00376 | 4.96 | 11.90 |
| Strut | 50/50 | 1.000 [1.000, 1.000] | 0.00041 | 3.14 | 10.92 |
| Blend | 68/100 | 0.680 [0.590, 0.770] | 0.01127 | 17.17 | 19.44 |
| Learned tables, full catalogue, seeds 0–2 | |||||
| All | 500/600 | 0.833 [0.792, 0.873] | 0.00672 | 10.95 | 15.34 |
| TPMS | 147/150 | 0.980 [0.940, 1.000] | 0.00361 | 5.74 | 11.50 |
| Strut | 147/150 | 0.980 [0.947, 1.000] | 0.00068 | 3.53 | 10.91 |
| Blend | 206/300 | 0.687 [0.607, 0.763] | 0.01129 | 17.26 | 19.48 |
| Catalogue tables, 14 blend architectures held out | |||||
| All | 166/200 | 0.830 [0.785, 0.875] | 0.00715 | 11.11 | 15.92 |
| TPMS | 49/50 | 0.980 [0.940, 1.000] | 0.00383 | 4.84 | 11.90 |
| Strut | 50/50 | 1.000 [1.000, 1.000] | 0.00041 | 2.96 | 10.92 |
| Blend | 67/100 | 0.670 [0.580, 0.760] | 0.01218 | 18.32 | 20.43 |
| Learned tables, 14 blend architectures held out | |||||
| All | 503/600 | 0.838 [0.797, 0.878] | 0.00621 | 11.24 | 15.48 |
| TPMS | 147/150 | 0.980 [0.947, 1.000] | 0.00342 | 5.86 | 11.42 |
| Strut | 147/150 | 0.980 [0.940, 1.000] | 0.00069 | 3.16 | 10.81 |
| Blend | 209/300 | 0.697 [0.617, 0.773] | 0.01037 | 17.97 | 19.85 |
| Oracle table | |||||
| All | 193/200 | 0.965 [0.940, 0.990] | 0.00317 | 3.79 | 11.21 |
| TPMS | 49/50 | 0.980 [0.940, 1.000] | 0.00228 | 2.24 | 10.48 |
| Strut | 49/50 | 0.980 [0.940, 1.000] | 0.00086 | 2.12 | 10.62 |
| Blend | 95/100 | 0.950 [0.900, 0.990] | 0.00477 | 5.40 | 11.86 |
Table S18. Table-quality controls and held-out architectures on the 200 confirmatory targets (50 TPMS, 50 strut, 100 blend). All searches keep the same schedule, at most 30 simulator calls, a 2% stop rule and the 3²³ simulator, with zero language-model calls. Learned arms use seeds 0–2; deterministic arms count once. Intervals bootstrap targets within system. The degraded table uses one density fit per system, shared by all its architectures. Only the oracle uses extra simulator data (6,048 construction calls outside search budgets). The held-out test removes 38 designs of 14 blend architectures, leaving 320 designs, and rebuilds both table types. These controls were planned after the confirmatory results were known and are not declared endpoints. All 2,400 existing runs were first reproduced identically. TPMS denotes triply periodic minimal surface
| Targets | Success difference | 95% interval | Error difference | 95% interval | |
| Degraded minus catalogue tables | |||||
| All | 200 | −0.475 | [−0.545, −0.405] | +0.01386 | [0.01132, 0.01654] |
| Blend | 100 | −0.490 | [−0.590, −0.380] | +0.01520 | [0.01192, 0.01870] |
| Oracle minus catalogue tables | |||||
| All | 200 | +0.130 | [0.085, 0.180] | −0.00351 | [−0.00487, −0.00238] |
| Blend | 100 | +0.270 | [0.190, 0.360] | −0.00650 | [−0.00915, −0.00434] |
| Learned minus catalogue tables, full catalogue, seeds 0–2 | |||||
| All | 200 | −0.002 | [−0.042, 0.038] | +0.00004 | [−0.00095, 0.00094] |
| Blend | 100 | +0.007 | [−0.070, 0.087] | +0.00002 | [−0.00190, 0.00173] |
| Learned minus catalogue tables, 14 architectures held out | |||||
| All | 200 | +0.008 | [−0.028, 0.045] | −0.00094 | [−0.00248, 0.00044] |
| Blend | 100 | +0.027 | [−0.040, 0.097] | −0.00182 | [−0.00483, 0.00095] |
| Catalogue tables, held out minus full catalogue | |||||
| All | 200 | −0.005 | [−0.030, 0.015] | +0.00048 | [−0.00007, 0.00128] |
| Targets | Success difference | 95% interval | Error difference | 95% interval | |
| Blend | 100 | ||||
| Learned tables, held out minus full catalogue | |||||
| All | 200 | ||||
| Blend | 100 | ||||
| Learned minus catalogue tables, held-out blend subgroups | |||||
| Held-out reference | 22 | ||||
| Other blends | 78 |
Table S19. Table S19: Paired table-control contrasts on the confirmatory targets. Entries are the first arm minus the second, averaged over seeds within target; intervals are 95% percentile target-bootstrap intervals (20,000 resamples within system, or within subgroup), unadjusted for multiplicity. Full-catalogue and held-out learned arms use seeds 0–2, and deterministic arms count once. These post-plan controls are not declared confirmatory endpoints. All searches have at most 30 simulator calls per target and zero language-model calls; the oracle’s extra construction calls are stated in Table S18. The four held-out endpoints (success rate and design error, all and blend) detect no difference. The subgroup of 22 held-out-reference targets leaves smaller benefits unresolved. One random subset of 14 architectures was tested; the planned 28-architecture level was not run because the earlier stages exceeded the plan’s time limit. The coarse oracle table still misses seven targets. No intermediate degradation was tested.
When we remove the catalogue examples of 14 blend architectures, the paired intervals for learned versus catalogue tables include zero for success and design error, overall and on blends. Blend success differs by 0.027 [−0.040, 0.097]. For the 22 targets whose reference architecture is held out, the success difference is 0.061 [−0.030, 0.182], leaving gains up to about 0.18 unresolved. Removing these architectures changes overall success little for either table type. This test uses one held-out subset and three learned-table seeds. The planned comparison holding out 28 architectures was omitted when earlier runs exceeded the plan’s time limit. The oracle still misses seven targets. We tested one level of degradation.
Table-guided searches outperform retrieval with pattern search on the test set
On the 36-target test set, the learned-table search meets 84 of 108 runs, compared with 23 for retrieval with pattern search, none for retrieval alone and two for random search (Table 4, Figure 6). Retrieval with pattern search uses step sizes fixed before test evaluation. The standard optimisers provide additional comparisons under the same call allowance. Mean design error is 0.00639 for the learned-table search and 0.03264 for retrieval with pattern search, a paired difference of −0.02625 with 95% interval [−0.03751, −0.01697]. The learned-table search has lower mean error on 32 targets and ties on four (two-sided sign test ). The success-rate difference is 0.565 with interval [0.417, 0.704]. It meets all 23 runs met by retrieval with pattern search and another 61.
| Configuration | Runs met | Success rate | Design error | Calls to success | Simulator calls per target |
| Learned-table search | 84/108 | 0.778 (0.139) [0.676, 0.880] | 0.00639 (0.00065) [0.00471, 0.00848] | 13.19 (0.22) | 17.03 |
| Catalogue-table search | 78/108 | 0.722 (—) [0.611, 0.833] | 0.00800 (—) [0.00463, 0.01374] | 13.86 (—) | 17.86 |
| Bracketing search | 72/108 | 0.667 (—) | 0.01138 (—) | 12.36 (—) | 12.03 |
| Bayesian optimisation | 71/108 | 0.657 (0.083) | 0.00958 (0.00100) | 14.99 (2.56) | 14.65 |
| Nelder–Mead search | 69/108 | 0.639 (—) | 0.01627 (—) | 14.97 (—) | 14.61 |
| Retrieval with pattern search | 23/108 | 0.213 (0.028) [0.102, 0.333] | 0.03264 (0.00180) [0.02270, 0.04439] | 26.47 (0.39) | 29.56 |
| Retrieval control | 0/108 | 0.000 (—) [0.000, 0.000] | 0.05352 (—) [0.03850, 0.07252] | 31.00 (—) | 0.00 |
| Random control | 2/108 | 0.019 (0.028) [0.000, 0.046] | 0.14299 (0.02949) [0.09814, 0.19672] | 30.76 (0.58) | 30.00 |
Table 4. Test comparison over 36 targets three seeds, with at most 30 simulator calls per target. Means are followed by seed ranges in parentheses. A dash denotes a deterministic configuration. Bracketed entries give 95% target-bootstrap intervals. Deterministic counts correspond to 26/36 catalogue-table, 24/36 bracketing, 23/36 Nelder–Mead and 0/36 retrieval targets. Boundary intervals carry no information about new targets. All configurations use zero language-model calls. Calls to success includes failures at 31. Per-system results are in the Supplementary Information.
Figure 6. Test results at a budget of 30 simulator calls. a Success rate by target system and overall. Bars average three seeds, and dots show each seed. b Mean design error on a log scale. The dashed line marks 2%, and floor triangles mark means below . c Fraction of runs with a successful query by each call. Thick curves pool seeds, and thin curves show each seed. The retrieval control used zero calls and met zero targets. TPMS denotes triply periodic minimal surface
The learned-table search uses 17.03 simulator calls per target on average, compared with 29.56 for retrieval with pattern search. Mean calls to success, with a value of 31 assigned to failures, are 13.19 and 26.47, respectively. Within ten calls, the learned-table search has met 53 runs and retrieval with pattern search 15. The learned-table search improves the success rate in each system by 0.56 to 0.59. It meets 25 of 27 TPMS runs, 27 of 27 strut runs and 32 of 54 blend runs, compared with 9, 12 and 2 for retrieval with pattern search. The blend runs remain the least frequently solved.
Bracketing search, Bayesian optimisation and Nelder–Mead search meet 72, 71 and 69 runs, respectively, compared with 23 for retrieval with pattern search. Their blend successes are 21, 21 and 18 of 54, and each meets all 27 strut runs. The learned-table search meets 12 more runs than bracketing search, the most successful standard optimiser, a success-rate difference of 0.111 that is smaller than the learned search’s 0.139 spread across its three seeds. Bayesian optimisation has the lowest mean design error among the standard optimisers (0.00958), compared with 0.00639 for the learned-table search. Bracketing search meets 69 runs within ten calls and has mean calls to success of 12.36, compared with 53 and 13.19 for learned-table search. Standard optimisers therefore close much of the difference from retrieval with pattern search. On the separate development set, the learned-table search meets 10 of 12 targets and retrieval with pattern search meets five.
Standard optimisers use fewer calls at the 2% tolerance
On the 200-target confirmatory set, the standard optimisers use fewer simulator calls per target at the 2% tolerance. Learned-table search uses 15.27 calls, compared with 9.31 for bracketing search, 12.02 for Bayesian optimisation and 13.87 for Nelder–Mead search. Both table-guided searches meet more specifications. Overall success-rate differences for learned-table search against bracketing, Bayesian optimisation and Nelder–Mead are 0.059 [0.019, 0.099], 0.121 [0.083, 0.158] and 0.128 [0.079, 0.179]. Catalogue-table search also has positive intervals against all three. These differences arise mainly on blends, where they are 0.133 [0.059, 0.212], 0.200 [0.133, 0.266] and 0.243 [0.152, 0.337]. On the 100 pure targets bracketing search meets every target, and learned-table search meets 984 of its 1,000 runs. Bayesian optimisation is also behind on TPMS targets, by 0.098 [0.040, 0.168]. Bracketing search holds blend weight at the table optimum, leaving density as its only way to refine a blend. The matched-stop tests in Sect. 6.8 show how the comparison changes at 5% tolerance.
Remaining misses concentrate on blend targets
On the test set, the learned-table search misses blend targets more often than pure targets. The learned-table search meets 14 of 18 blend targets for at least one seed and eight for all three seeds (Figure 7). Retrieval with pattern search meets one blend target for two seeds. On the pure systems, the only learned-table-search misses are two seeds on the same TPMS target. Both the learned-table search and the catalogue-table search reproduce the strut targets to rounding precision on the voxel grid. In one successful TPMS run, the returned design belongs to a different system. All returned designs from the learned-table search pass the simulator’s validity checks, including those that miss the tolerance.
Figure 7. Verified successes by test target. Columns follow benchmark order within each system. Each entry shows how many of three seeds met the tolerance after re-simulation of the returned design. The right columns total successes over all 108 runs and over the 54 blend runs. Deterministic variants can show only zero or three successes for a target. TPMS denotes triply periodic minimal surface.
Three-architecture catalogue search uses fewer calls
To examine the choice between testing another architecture and sizing a queried one, we restrict the architectures available after the first batch. On the 36-target test set, a search that uses catalogue-fitted tables and stays in its three best table-ranked architectures reaches 84 successes, with five successes unique to each of this variant and the learned-table search. It uses 10.81 calls per target and has mean calls to success of 9.94, compared with 17.03 and 13.19 for the learned-table search. The paired difference in calls to success is 3.24 for the learned-table search minus the three-architecture catalogue search (interval [0.96, 5.67]). The three-architecture catalogue search has higher mean design error (0.01010 versus 0.00639), with a paired interval for the error difference that includes zero.
The same restriction to three architectures with learned tables meets 71 runs. Initial batches of 3, 6, 10 and 15 architectures in the broader learned-table search give 83, 87, 84 and 79 successes, respectively. The six-architecture setting was evaluated on these test targets and its 87 successes are an exploratory result. Using one, three or nine neural networks gives 80, 84 and 82 successes, with no detected paired difference in mean error. Figure 8 summarises the component results and seed variation.
Figure 8. Ablations and sensitivity analyses under the common call budget. a,b Mean design error over all runs and over blend runs. c Blend success rate. d Mean calls to success over all runs. Diamonds show means, connected points show seed results, and the vertical band and line show the learned-table search’s seed range and mean. Deterministic variants have a single point. The threshold in a,b is , the 2% tolerance. These displays show seed variation. Target-level intervals are reported in the Supplementary Information
The three-architecture catalogue search also improves the success rate by 0.361 relative to using the three catalogue starts of retrieval with pattern search with corrected refinement (interval [0.194, 0.528]). Among the 63 runs that miss with corrected refinement from those starts, at least one of learned-table search, catalogue-table search, three-architecture catalogue search or retrieval with pattern search succeeds in 45. In each of those runs, a successful alternative uses an architecture outside those three starts. The comparison changes which architectures are tried, where they are started and how calls are allocated, so it cannot isolate a ranking-only effect.
These comparisons estimate how two sets of search choices contribute to the gain over retrieval with pattern search. From the three retrieved starts, pattern search meets 23 runs and corrected refinement meets 45. Under the table-ranked schedule, pattern search as the refinement rule meets 59 runs, and corrected refinement meets 84 with learned tables and 78 with catalogue tables. Changing the ranking, the starting designs and the allocation together therefore adds 36 runs under pattern search and 33 to 39 runs under corrected refinement. Changing the refinement rule adds 22 runs from the retrieved starts and 25 under the learned-table schedule. These arms assess the bundle of table-based ranking, starts and allocation separately from the refinement rule. The pattern-search arm under the table-ranked schedule was run with learned tables only, so its comparison with the 78 catalogue-table runs also changes the table type.
On the confirmatory set, three-architecture catalogue search meets 170 of 200 targets (85.0%), compared with 84.4% success for learned-table search, averaging its ten seeds for each target. Its 8.40 calls to success and 9.05 simulator calls per target compare with 10.82 and 15.27 for learned-table search. The paired calls-to-success difference is 2.42 [1.40, 3.41]. These secondary contrasts are descriptive.
Smaller target sets and catalogue coverage
The 36-target test set and fresh draw give exploratory estimates. We analysed these comparisons post hoc, after the development screen. Figure 9a compares four smaller sets. Panels b and c show what changes when the test and fresh-draw searches use wider tolerances.
Figure 9. Target sets and matched stop rules. a Success rates for the seven fixed configurations on the test set, fresh draw, interpolated responses and responses. Each has 36 targets and three seeds, at most 30 simulator calls per target and a search simulator. Bars give means, dots give seeds and numbers give runs met. Reachability is unknown for the last two sets. b,c Test-set and fresh-draw successes at 2%, 3% and 5%. Filled markers use the matched stop rule. Larger open markers show 2%-stop-rule returns re-scored where the counts differ. The vertical axes start at 15 runs. Retrieval with pattern search uses re-scoring because it has no early stop. TPMS denotes triply periodic minimal surface
On the test set, learned tables meet 84 runs and catalogue tables meet 78. The paired success-rate difference is 0.056 with 95% interval , and the blend difference is 0.148 with interval . Mean design error differs by , with interval . These intervals describe target variation, while the three-seed ranges are 0.139 for overall success and 0.222 for blend success. On the development set, both catalogue variants meet 11 of 12 targets and learned-table search meets ten (Table S7 in the Supplementary Information).
| Variant | Targets met (TPMS / strut / blend) | Design error all | Design error blend | Calls to success | Simulator calls per target |
| Reference | |||||
| Learned-table search | 10/12 (3 / 3 / 4) | 0.00607 | 0.00986 | 11.17 | 15.17 |
| Learned component Catalogue-table search | 11/12 (3 / 3 / 5) | 0.00944 | 0.01649 | 8.17 | 13.67 |
| Categorical-encoding search | 11/12 (3 / 3 / 5) | 0.01149 | 0.01996 | 12.58 | 17.00 |
| Role of the learned tables | |||||
| Learned tables for ranking only | 10/12 (3 / 3 / 4) | 0.00602 | 0.00976 | 10.83 | 15.00 |
| Learned tables for refinement only | 11/12 (3 / 3 / 5) | 0.00944 | 0.01649 | 10.33 | 15.75 |
| Simulator feedback | |||||
| Uncorrected-proposal control | 8/12 (3 / 2 / 3) | 0.02395 | 0.04001 | 14.75 | 18.33 |
| No-residual control | 8/12 (3 / 2 / 3) | 0.02346 | 0.03904 | 14.75 | 18.33 |
| Pattern-search refinement | 8/12 (3 / 2 / 3) | 0.01471 | 0.02188 | 17.50 | 21.00 |
| Architectures searched | |||||
| Three architectures with learned tables | 11/12 (3 / 3 / 5) | 0.00636 | 0.01043 | 6.83 | 7.92 |
| Three-architecture catalogue search | 11/12 (3 / 3 / 5) | 0.00972 | 0.01704 | 5.08 | 6.58 |
| First batch of 3 architectures | 11/12 (3 / 3 / 5) | 0.00636 | 0.01043 | 7.67 | 8.92 |
| First batch of 6 architectures | 11/12 (3 / 3 / 5) | 0.00580 | 0.00932 | 9.17 | 11.67 |
| First batch of 15 architectures | 10/12 (3 / 3 / 4) | 0.00807 | 0.01385 | 13.25 | 19.33 |
| Ensemble size | |||||
| 1 MLP | 10/12 (3 / 3 / 4) | 0.00708 | 0.01188 | 10.75 | 15.00 |
| 9 MLPs | 10/12 (3 / 3 / 4) | 0.01279 | 0.02331 | 10.33 | 15.00 |
| Catalogue starts | |||||
| Pattern-search starts with corrected refinement | 4/12 (2 / 2 / 0) | 0.02171 | 0.03188 | 22.33 | 19.67 |
| Retrieval with pattern search | 5/12 (2 / 3 / 0) | 0.02477 | 0.04299 | 22.58 | 30.00 |
| Controls | |||||
| Retrieval control | 0/12 (0 / 0 / 0) | 0.07154 | 0.07280 | 31.00 | 0.00 |
| Random control | 0/12 (0 / 0 / 0) | 0.16747 | 0.13537 | 31.00 | 30.00 |
Table S7. Development-set outcomes for 12 targets (3 TPMS, 3 strut and 6 blend) with one seed and at most 30 simulator calls per target. TPMS denotes triply periodic minimal surface
Pooling the test set and fresh draw gives an exploratory advantage for learned tables. Across 72 reachable targets, the success rate is 6.0 percentage points higher, with a paired 95% interval from 0.9 to 11.6 points. The intervals for design error and calls to success include zero. The learned configuration had passed a development check against catalogue tables, and the larger confirmatory comparison does not reproduce the pooled advantage. Table S13–Table S15 in the Supplementary Information give the paired outcomes and contrasts.
| System (targets) | Success rate | Design error | Calls to success |
| Test set. Learned-table search minus Catalogue-table search | |||
| All (36) | +0.056<br>[−0.019, 0.139]<br> | −0.00161<br>[−0.00605, 0.00122]<br> | −0.68<br>[−2.95, 1.44]<br> |
| TPMS (9) | −0.074<br>[−0.222, 0.000]<br> | +0.00044<br>[−0.00237, 0.00355]<br> | +2.70<br>[−1.56, 7.41]<br> |
| Strut (9) | +0.000<br>[0.000, 0.000]<br> | +0.00000<br>[0.00000, 0.00000]<br> | −1.37<br>[−5.37, 1.48]<br> |
| Blend (18) | +0.148<br>[0.019, 0.296]<br> | −0.00344<br>[−0.01212, 0.00183]<br> | −2.02<br>[−5.50, 1.15]<br> |
| Test set. Learned-table search minus Bracketing search | |||
| All (36) | +0.111<br>[0.000, 0.213]<br> | −0.00499<br>[−0.01257, 0.00015]<br> | +0.82<br>[−0.94, 2.78]<br> |
| TPMS (9) | +0.037<br>[0.000, 0.111]<br> | +0.00078<br>[−0.00177, 0.00307]<br> | +1.59<br>[0.22, 2.89]<br> |
| Strut (9) | +0.000<br>[0.000, 0.000]<br> | +0.00000<br>[0.00000, 0.00000]<br> | +1.41<br>[−0.67, 3.74]<br> |
| Blend (18) | +0.204<br>[−0.019, 0.407]<br> | −0.01038<br>[−0.02562, −0.00019]<br> | +0.15<br>[−3.11, 3.89]<br> |
| Test set. Learned-table search minus Bayesian optimisation | |||
| All (36) | +0.120<br>[0.019, 0.222]<br> | −0.00319<br>[−0.00679, −0.00065]<br> | −1.81<br>[−4.57, 0.67]<br> |
| System (targets) | Success rate | Design error | Calls to success |
| TPMS (9) | +0.074<br>[-0.185, 0.370]<br> | -0.00045<br>[-0.00292, 0.00235]<br> | -1.44<br>[-8.96, 3.78]<br> |
| Strut (9) | +0.000<br>[0.000, 0.000]<br>— | +0.00000<br>[0.00000, 0.00000]<br>— | +1.85<br>[0.37, 3.85]<br> |
| Blend (18) | +0.204<br>[0.056, 0.370]<br> | -0.00615<br>[-0.01319, -0.00137]<br> | -3.81<br>[-8.07, -0.09]<br> |
| Test set. Learned-table search minus Nelder–Mead search | |||
| All (36) | +0.139<br>[0.028, 0.250]<br> | -0.00988<br>[-0.01744, -0.00384]<br> | -1.79<br>[-4.06, 0.61]<br> |
| TPMS (9) | +0.037<br>[0.000, 0.111]<br> | -0.00179<br>[-0.00379, 0.00034]<br> | -0.52<br>[-3.41, 1.48]<br> |
| Strut (9) | +0.000<br>[0.000, 0.000]<br>— | +0.00000<br>[0.00000, 0.00000]<br>— | -0.04<br>[-4.00, 2.74]<br> |
| Blend (18) | +0.259<br>[0.037, 0.481]<br> | -0.01886<br>[-0.03386, -0.00670]<br> | -3.30<br>[-7.20, 1.06]<br> |
| Fresh draw. Learned-table search minus Catalogue-table search | |||
| All (36) | +0.065<br>[-0.009, 0.148]<br> | -0.00096<br>[-0.00189, -0.00020]<br> | -0.95<br>[-2.82, 0.82]<br> |
| TPMS (9) | +0.000<br>[0.000, 0.000]<br>— | +0.00054<br>[-0.00029, 0.00191]<br> | +3.30<br>[1.04, 5.81]<br> |
| Strut (9) | +0.000<br>[0.000, 0.000]<br>— | -0.00065<br>[-0.00194, 0.00000]<br> | -3.00<br>[-7.93, 0.67]<br> |
| Blend (18) | +0.130<br>[-0.019, 0.296]<br> | -0.00186<br>[-0.00353, -0.00068]<br> | -2.06<br>[-4.50, 0.59]<br> |
| Fresh draw. Learned-table search minus Bracketing search | |||
| All (36) | +0.065<br>[-0.009, 0.148]<br> | +0.00109<br>[-0.00209, 0.00577]<br> | +1.80<br>[-0.13, 3.81]<br> |
| TPMS (9) | +0.000<br>[0.000, 0.000]<br>— | +0.00833<br>[-0.00155, 0.02554]<br> | +3.41<br>[1.19, 5.89]<br> |
| Strut (9) | +0.000<br>[0.000, 0.000]<br>— | +0.00000<br>[0.00000, 0.00000]<br>— | +0.11<br>[-0.19, 0.48]<br> |
| Blend (18) | +0.130<br>[-0.019, 0.296]<br> | -0.00198<br>[-0.00495, 0.00028]<br> | +1.83<br>[-1.78, 5.76]<br> |
| Fresh draw. Learned-table search minus Bayesian optimisation | |||
| All (36) | +0.093<br>[0.019, 0.157]<br> | -0.00107<br>[-0.00258, 0.00071]<br> | -0.89<br>[-2.52, 0.73]<br> |
| TPMS (9) | +0.037<br>[0.000, 0.111]<br> | +0.00045<br>[-0.00321, 0.00566]<br> | +1.70<br>[-1.52, 4.41]<br> |
| Strut (9) | +0.000<br>[0.000, 0.000]<br>— | -0.00000<br>[-0.00000, 0.00000]<br>— | +0.93<br>[0.15, 1.96]<br> |
| Blend (18) | +0.167<br>[0.019, 0.296]<br> | -0.00236<br>[-0.00459, 0.00019]<br> | -3.09<br>[-5.96, -0.20]<br> |
| Fresh draw. Learned-table search minus Nelder–Mead search | |||
| All (36) | +0.148<br>[0.065, 0.250]<br> | +0.00093<br>[-0.00544, 0.01064]<br> | -4.62<br>[-7.13, -2.25]<br> |
| TPMS (9) | +0.111<br>[0.000, 0.333]<br> | +0.01522<br>[-0.00648, 0.05227]<br> | -2.59<br>[-9.93, 4.00]<br> |
| System (targets) | Success rate | Design error | Calls to success |
| Strut (9) | +0.000 [0.000, 0.000] | -0.00000 [-0.00000, 0.00000] | -2.89 [-7.19, 0.11] |
| Blend (18) | +0.241 [0.093, 0.407] | -0.00576 [-0.01042, -0.00209] | -6.50 [-9.43, -3.72] |
| Interpolated responses. Learned-table search minus Catalogue-table search | |||
| All (36) | -0.000 [-0.102, 0.102] | -0.00359 [-0.01064, 0.00126] | -0.49 [-2.85, 1.94] |
| TPMS (9) | +0.148 [-0.148, 0.444] | -0.00144 [-0.00354, 0.00037] | -2.52 [-8.33, 3.48] |
| Strut (9) | -0.111 [-0.259, 0.000] | +0.00068 [-0.00133, 0.00279] | +1.07 [-3.04, 5.74] |
| Blend (18) | -0.019 [-0.148, 0.111] | -0.00680 [-0.02109, 0.00290] | -0.26 [-3.30, 2.94] |
| Interpolated responses. Learned-table search minus Bracketing search | |||
| All (36) | +0.139 [0.019, 0.259] | +0.00015 [-0.00288, 0.00354] | +0.73 [-2.02, 3.66] |
| TPMS (9) | +0.148 [-0.148, 0.444] | -0.00222 [-0.00413, -0.00053] | +0.81 [-5.11, 7.85] |
| Strut (9) | -0.000 [-0.111, 0.111] | -0.00116 [-0.00246, -0.00015] | +2.30 [-0.19, 5.74] |
| Blend (18) | +0.204 [0.037, 0.389] | +0.00199 [-0.00387, 0.00870] | -0.09 [-4.46, 4.31] |
| Interpolated responses. Learned-table search minus Bayesian optimisation | |||
| All (36) | +0.139 [0.046, 0.241] | -0.00012 [-0.00807, 0.00862] | -2.42 [-4.75, -0.13] |
| TPMS (9) | +0.222 [0.000, 0.407] | -0.00187 [-0.00444, 0.00040] | -3.15 [-6.11, 0.07] |
| Strut (9) | +0.000 [-0.111, 0.111] | -0.00077 [-0.00173, 0.00056] | -1.30 [-6.70, 3.56] |
| Blend (18) | +0.167 [0.019, 0.333] | +0.00108 [-0.01494, 0.01889] | -2.61 [-6.09, 0.85] |
| Interpolated responses. Learned-table search minus Nelder–Mead search | |||
| All (36) | +0.333 [0.222, 0.454] | -0.00648 [-0.01261, -0.00129] | -5.24 [-7.70, -2.79] |
| TPMS (9) | +0.481 [0.222, 0.741] | -0.00670 [-0.01287, -0.00262] | -9.63 [-15.33, -4.44] |
| Strut (9) | -0.000 [-0.111, 0.111] | -0.00083 [-0.00190, 0.00004] | +0.74 [-0.37, 2.52] |
| Blend (18) | +0.426 [0.241, 0.611] | -0.00919 [-0.02128, 0.00102] | -6.04 [-10.00, -1.94] |
| responses. Learned-table search minus Catalogue-table search | |||
| All (36) | -0.009 [-0.102, 0.093] | +0.00399 [-0.00122, 0.01313] | -0.82 [-3.19, 1.68] |
| TPMS (9) | +0.000 [0.000, 0.000] | +0.01799 [0.00002, 0.05321] | -1.81 [-3.93, 0.00] |
| Strut (9) | -0.037 [-0.333, 0.296] | -0.00123 [-0.00374, 0.00114] | +0.22 [-4.89, 5.81] |
| System (targets) | Success rate | Design error | Calls to success |
| Blend (18) | -0.000 [−0.111, 0.111] | -0.00040 [−0.00231, 0.00112] | -0.85 [−4.56, 3.28] |
| responses. Learned-table search minus Bracketing search | |||
| All (36) | +0.046 [−0.046, 0.148] | +0.00298 [−0.00183, 0.01141] | +0.54 [−2.24, 3.20] |
| TPMS (9) | +0.000 [0.000, 0.000] — | +0.01631 [−0.00102, 0.04907] | +0.85 [−1.00, 3.41] |
| Strut (9) | −0.148 [−0.370, 0.000] | +0.00017 [−0.00112, 0.00179] | +3.00 [−2.67, 9.07] |
| Blend (18) | +0.167 [0.019, 0.352] | −0.00229 [−0.00413, −0.00070] | −0.85 [−5.48, 3.30] |
| responses. Learned-table search minus Bayesian optimisation | |||
| All (36) | +0.120 [0.028, 0.231] | +0.00309 [−0.00209, 0.01224] | −2.35 [−5.07, 0.12] |
| TPMS (9) | +0.074 [−0.074, 0.259] | +0.01772 [−0.00094, 0.05316] | −2.59 [−7.81, 1.59] |
| Strut (9) | +0.185 [0.000, 0.407] | −0.00147 [−0.00355, −0.00000] | −4.85 [−9.96, 0.00] |
| Blend (18) | +0.111 [−0.037, 0.278] | −0.00194 [−0.00377, −0.00014] | −0.98 [−5.19, 2.61] |
| responses. Learned-table search minus Nelder–Mead search | |||
| All (36) | +0.157 [0.019, 0.296] | +0.00371 [−0.00445, 0.01818] | −4.19 [−7.28, −1.01] |
| TPMS (9) | +0.111 [0.000, 0.333] | +0.02537 [−0.00517, 0.08260] | −2.70 [−7.00, 0.22] |
| Strut (9) | −0.037 [−0.333, 0.296] | −0.00040 [−0.00288, 0.00142] | +2.11 [−4.93, 10.30] |
| Blend (18) | +0.278 [0.093, 0.481] | −0.00507 [−0.00761, −0.00297] | −8.07 [−12.72, −3.54] |
| Test set and fresh draw pooled. Learned-table search minus Catalogue-table search | |||
| All (72) | +0.060 [0.009, 0.116] | −0.00128 [−0.00358, 0.00023] | −0.81 [−2.29, 0.59] |
| TPMS (18) | −0.037 [−0.111, 0.000] | +0.00049 [−0.00106, 0.00218] | +3.00 [0.57, 5.61] |
| Strut (18) | +0.000 [0.000, 0.000] — | −0.00032 [−0.00097, 0.00000] | −2.19 [−5.31, 0.43] |
| Blend (36) | +0.139 [0.037, 0.250] | −0.00265 [−0.00709, 0.00017] | −2.04 [−4.09, 0.00] |
| Test set and fresh draw pooled. Learned-table search minus Bracketing search | |||
| All (72) | +0.088 [0.023, 0.153] | −0.00195 [−0.00611, 0.00165] | +1.31 [0.00, 2.69] |
| TPMS (18) | +0.019 [0.000, 0.056] | +0.00456 [−0.00078, 0.01339] | +2.50 [1.17, 3.91] |
| Strut (18) | +0.000 [0.000, 0.000] — | +0.00000 [0.00000, 0.00000] — | +0.76 [−0.26, 1.93] |
| Blend (36) | +0.167 [0.037, 0.296] | −0.00618 [−0.01402, −0.00088] | +0.99 [−1.47, 3.65] |
| System (targets) | Success rate | Design error | Calls to success |
| Test set and fresh draw pooled. Learned-table search minus Bayesian optimisation | |||
| All (72) | +0.106 [0.046, 0.167] | -0.00213 [-0.00410, -0.00056] | -1.35 [-2.95, 0.14] |
| TPMS (18) | +0.056 [-0.074, 0.204] | +0.00000 [-0.00232, 0.00284] | +0.13 [-3.83, 3.22] |
| Strut (18) | +0.000 [0.000, 0.000] | -0.00000 [-0.00000, 0.00000] | +1.39 [0.46, 2.52] |
| Blend (36) | +0.185 [0.083, 0.287] | -0.00425 [-0.00798, -0.00145] | -3.45 [-6.04, -1.06] |
| Test set and fresh draw pooled. Learned-table search minus Nelder–Mead search | |||
| All (72) | +0.144 [0.074, 0.218] | -0.00447 [-0.00964, 0.00133] | -3.20 [-4.90, -1.54] |
| TPMS (18) | +0.074 [0.000, 0.204] | +0.00671 [-0.00422, 0.02532] | -1.56 [-5.48, 1.98] |
| Strut (18) | +0.000 [0.000, 0.000] | -0.00000 [-0.00000, 0.00000] | -1.46 [-4.26, 0.81] |
| Blend (36) | +0.250 [0.120, 0.389] | -0.01231 [-0.02011, -0.00588] | -4.90 [-7.31, -2.34] |
Table S13. Paired contrasts for the test set, additional sets and pooled reachable targets. Entries give mean difference, 95% target-bootstrap interval and two-sided sign-test p value, with seeds averaged within target. Positive success and negative error or calls favour the first configuration. Targets are resampled within system and within set for pooling. These post hoc contrasts are unadjusted for multiplicity. Every search uses at most 30 simulator calls per target and zero language-model calls. Boundary intervals carry no information about performance on new targets.
| System (targets) | Success rate | Design error | Calls to success |
| Learned-table search minus Catalogue-table search | |||
| All (200) | +0.008 [-0.027, 0.045] | +0.00002 [-0.00104, 0.00099] | +0.21 [-0.65, 1.07] |
| TPMS (50) | +0.008 [-0.006, 0.030] | -0.00032 [-0.00110, 0.00045] | +0.68 [-0.37, 1.71] |
| Strut (50) | -0.020 [-0.058, 0.000] | +0.00022 [-0.00041, 0.00104] | +0.13 [-1.12, 1.36] |
| Blend (100) | +0.023 [-0.044, 0.093] | +0.00008 [-0.00195, 0.00195] | +0.01 [-1.49, 1.51] |
| Learned-table search minus Three-architecture catalogue search | |||
| All (200) | -0.007 [-0.043, 0.030] | -0.00076 [-0.00241, 0.00074] | +2.42 [1.40, 3.41] |
| TPMS (50) | +0.028 [-0.004, 0.080] | -0.00193 [-0.00519, 0.00007] | +2.40 [1.11, 3.59] |
| Strut (50) | +0.000 [-0.054, 0.058] | -0.00118 [-0.00405, 0.00067] | +0.85 [-0.91, 2.51] |
| Blend (100) | -0.027 [-0.090, 0.037] | +0.00003 [-0.00262, 0.00254] | +3.21 [1.47, 4.95] |
| Learned-table search minus Bracketing search | |||
| All (200) | +0.059 [0.019, 0.099] | -0.00151 [-0.00242, -0.00067] | +1.29 [0.27, 2.32] |
| System (targets) | Success rate | Design error | Calls to success |
| -0.012 [-0.036, 0.000] | -0.00000 [-0.00097, 0.00097] | +2.86 [1.74, 4.01] | |
| TPMS (50) | -0.020 [-0.058, 0.000] | -0.00004 [-0.00084, 0.00086] | +1.25 [0.06, 2.74] |
| Strut (50) | +0.133 [0.059, 0.212] | -0.00300 [-0.00473, -0.00145] | +0.52 [-1.33, 2.35] |
| Learned-table search minus Bayesian optimisation | |||
| All (200) | +0.121 [0.083, 0.158] | -0.00110 [-0.00194, -0.00020] | -1.48 [-2.46, -0.51] |
| TPMS (50) | +0.098 [0.040, 0.168] | -0.00169 [-0.00266, -0.00075] | -0.33 [-2.37, 1.49] |
| Strut (50) | -0.016 [-0.056, 0.008] | -0.00013 [-0.00069, 0.00063] | +0.92 [-0.20, 2.25] |
| Blend (100) | +0.200 [0.133, 0.266] | -0.00129 [-0.00286, 0.00045] | -3.24 [-4.85, -1.67] |
| Learned-table search minus Nelder–Mead search | |||
| All (200) | +0.128 [0.079, 0.179] | -0.00259 [-0.00402, -0.00115] | -3.34 [-4.61, -2.10] |
| TPMS (50) | +0.028 [-0.004, 0.080] | -0.00076 [-0.00174, 0.00013] | -0.74 [-2.78, 1.10] |
| Strut (50) | +0.000 [-0.054, 0.058] | -0.00131 [-0.00419, 0.00059] | -2.11 [-4.47, 0.19] |
| Blend (100) | +0.243 [0.152, 0.337] | -0.00415 [-0.00665, -0.00154] | -5.25 [-7.30, -3.22] |
| Learned-table search minus Retrieval with pattern search | |||
| All (200) | +0.571 [0.510, 0.632] | -0.01644 [-0.01898, -0.01404] | -14.91 [-16.38, -13.42] |
| TPMS (50) | +0.628 [0.496, 0.758] | -0.01244 [-0.01626, -0.00887] | -18.15 [-21.39, -14.77] |
| Strut (50) | +0.300 [0.164, 0.440] | -0.00875 [-0.01335, -0.00464] | -14.42 [-17.42, -11.35] |
| Blend (100) | +0.678 [0.600, 0.753] | -0.02228 [-0.02661, -0.01850] | -13.54 [-15.45, -11.62] |
| Catalogue-table search minus Bracketing search | |||
| All (200) | +0.050 [0.015, 0.090] | -0.00153 [-0.00267, -0.00058] | +1.08 [0.12, 2.06] |
| TPMS (50) | -0.020 [-0.060, 0.000] | +0.00032 [-0.00052, 0.00122] | +2.18 [0.94, 3.58] |
| Strut (50) | +0.000 [0.000, 0.000] | -0.00026 [-0.00075, 0.00010] | +1.12 [-0.04, 2.52] |
| Blend (100) | +0.110 [0.040, 0.180] | -0.00309 [-0.00532, -0.00125] | +0.51 [-1.16, 2.15] |
| Catalogue-table search minus Bayesian optimisation | |||
| All (200) | +0.112 [0.068, 0.157] | -0.00112 [-0.00190, -0.00027] | -1.68 [-2.79, -0.60] |
| TPMS (50) | +0.090 [0.032, 0.160] | -0.00136 [-0.00244, -0.00031] | -1.02 [-2.56, 0.42] |
| System (targets) | Success rate | Design error | Calls to success |
| Strut (50) | +0.004 [0.000, 0.010] | −0.00036 [−0.00085, 0.00006] | +0.78 [−0.28, 2.01] |
| Blend (100) | +0.177 [0.095, 0.259] | −0.00137 [−0.00283, 0.00026] | −3.25 [−5.22, −1.29] |
| Catalogue-table search minus Nelder–Mead search | |||
| All (200) | +0.120 [0.070, 0.170] | −0.00261 [−0.00387, −0.00138] | −3.54 [−4.72, −2.38] |
| TPMS (50) | +0.020 [0.000, 0.060] | −0.00043 [−0.00140, 0.00032] | −1.42 [−3.18, 0.28] |
| Strut (50) | +0.020 [0.000, 0.060] | −0.00153 [−0.00421, −0.00001] | −2.24 [−4.46, −0.14] |
| Blend (100) | +0.220 [0.130, 0.320] | −0.00424 [−0.00639, −0.00203] | −5.26 [−7.12, −3.39] |
Table S15.
The coverage checks ask whether learning helps more when fewer catalogue designs are available. We detect no advantage when grouping blend targets by catalogue coverage or when repeating the comparison with fewer pure-architecture examples. The latter check retains all blend designs. Table S17 in the Supplementary Information gives the counts and intervals.
| Targets | Learned tables, runs met | Catalogue tables, targets met | Success difference | 95% interval | |
| Thinned catalogue (259 designs), learned-table seeds 0–2 | |||||
| All targets | 200 | 493/600 | 163/200 | +0.007 | [−0.032, +0.047] |
| TPMS targets | 50 | 143/150 | 48/50 | −0.007 | [−0.060, +0.040] |
| Strut targets | 50 | 139/150 | 48/50 | −0.033 | [−0.100, +0.013] |
| Blend targets | 100 | 211/300 | 67/100 | +0.033 | [−0.033, +0.103] |
| Full catalogue (358 designs), learned-table seeds 0–2 | |||||
| All targets | 200 | 500/600 | 167/200 | −0.002 | [−0.042, +0.038] |
| TPMS targets | 50 | 147/150 | 49/50 | +0.000 | [+0.000, +0.000] |
| Strut targets | 50 | 147/150 | 50/50 | −0.020 | [−0.053, +0.000] |
| Blend targets | 100 | 206/300 | 68/100 | +0.007 | [−0.070, +0.087] |
| Full catalogue, blend targets by catalogue designs of the reference architecture, ten seeds | |||||
| One or two designs | 30 | 251/300 | 24/30 | +0.037 | [−0.050, +0.143] |
| Three designs | 49 | 325/490 | 32/49 | +0.010 | [−0.080, +0.102] |
| Four designs | 21 | 127/210 | 12/21 | +0.033 | [−0.171, +0.238] |
Table S17. Learned-table minus catalogue-table search under reduced catalogue coverage, on the 200 confirmatory targets. The thinned catalogue keeps every second density of each pure architecture, starting from the lowest, and all blend designs; learned tables are trained on it and catalogue tables are fitted to it. Runs met are given for learned-table search (three seeds in the first two blocks, ten in the third) and for deterministic catalogue-table search, which counts once per target. Differences average seeds within target. The 95% intervals resample targets 20,000 times, within system in the first two blocks and within the row in the third. These analyses were added after the confirmatory plan and are not among its declared endpoints. All runs use at most 30 simulator calls per target and zero language-model calls
With early stopping set to the tolerance being tested, at 3% and 5%, learned-table and catalogue-table searches meet 92 versus 93 and 102 versus 105 test runs. On the fresh draw they meet 98 versus 90 and 101 versus 102 (Figure 9b,Figure 9c). The fresh-draw 3% success difference is 0.074 , the only one of these four paired intervals that excludes zero. The ordering varies with tolerance and set. Table S6 reports these runs alongside the 2%-stop-rule designs re-scored at wider tolerances. At 5%, Bayesian optimisation meets 101 test runs and 102 fresh-draw runs with 4.25 and 4.34 simulator calls per target, respectively.
| Variant | All targets (108 runs) 2 % | All targets (108 runs) 3 % | All targets (108 runs) 5 % | Blend targets (54 runs) 2 % | Blend targets (54 runs) 3 % | Blend targets (54 runs) 5 % |
| Learned-table search | 84 | 94 | 100 | 32 | 42 | 47 |
| Catalogue-table search | 78 | 99 | 105 | 24 | 45 | 51 |
| Categorical-encoding search | 79 | 91 | 98 | 25 | 37 | 44 |
| Uncorrected-proposal control | 65 | 75 | 87 | 17 | 27 | 36 |
| Three-architecture catalogue search | 84 | 96 | 99 | 30 | 42 | 45 |
| Pattern-search starts with corrected refinement | 45 | 51 | 69 | 18 | 24 | 36 |
| Retrieval with pattern search | 23 | 29 | 46 | 2 | 5 | 16 |
| Retrieval control | 0 | 0 | 6 | 0 | 0 | 3 |
| Random control | 2 | 3 | 7 | 0 | 1 | 4 |
| Matched stop rules (re-scored counts in parentheses) | ||||||
| Test set | ||||||
| Learned-table search | 84 | 92 (94) | 102 (100) | 32 | 40 (42) | 49 (47) |
| Catalogue-table search | 78 | 93 (99) | 105 (105) | 24 | 42 (45) | 51 (51) |
| Three-architecture catalogue search | 84 | 96 (96) | 99 (99) | 30 | 42 (42) | 45 (45) |
| Bracketing search | 72 | 84 (87) | 96 (96) | 21 | 30 (33) | 42 (42) |
| Bayesian optimisation | 71 | 87 (87) | 101 (101) | 21 | 33 (33) | 47 (47) |
| Nelder–Mead search | 69 | 75 (75) | 90 (90) | 18 | 24 (24) | 36 (36) |
| Retrieval with pattern search | 23 | 29 (29) | 46 (46) | 2 | 5 (5) | 16 (16) |
| Fresh draw | ||||||
| Learned-table search | 94 | 98 (99) | 101 (103) | 43 | 47 (48) | 50 (52) |
| Catalogue-table search | 87 | 90 (93) | 102 (102) | 36 | 39 (42) | 51 (51) |
| Three-architecture catalogue search | 93 | 93 (93) | 99 (99) | 45 | 45 (45) | 48 (48) |
| Bracketing search | 87 | 90 (93) | 96 (96) | 36 | 39 (42) | 45 (45) |
| Bayesian optimisation | 84 | 94 (94) | 102 (102) | 34 | 43 (43) | 51 (51) |
| Nelder–Mead search | 78 | 78 (78) | 96 (96) | 30 | 30 (30) | 45 (45) |
| Retrieval with pattern search | 27 | 37 (37) | 62 (62) | 0 | 10 (10) | 26 (26) |
Table S6. Table S6: Verified successes at relative tolerances of 2%, 3% and 5%. The first panel re-scores designs returned under the 2% stop rule. The second panel gives matched-stop-rule runs, with re-scored counts in parentheses at 3% and 5%. Every row uses at most 30 simulator calls per target and zero language-model calls
Among the learned variants, the shared encoding lowers mean error relative to the categorical-encoding search by 0.00414 overall (interval for shared minus categorical encoding) and by 0.00857 on blends (interval ). Success-rate intervals for those comparisons include zero. The shared encoding therefore helps the design-error metric in this comparison with an untuned categorical control. The role swap with learned tables for ranking and catalogue refinement meets 84 runs. The reverse swap meets 80. Compared with using catalogue-fitted tables throughout, learned tables for ranking lowers mean blend error by 0.00224, with an interval of for the difference.
The offline diagnostic gives little support for explaining the shared encoding’s lower design error by better architecture ranking. The shared encoding recovers fewer blend architectures in the first ten ranks and more in the first twenty than the categorical encoding (Figure S1 and Table S8 in the Supplementary Information). The verified search can meet the target through any architecture.
| Model | Rank 3 | Rank 10 | Rank 20 | |||
| All designs (358) | ||||||
| Learned tables | 0.301 (0.031) | 0.519 (0.011) | 0.703 (0.022) | 0.144 | 0.136 | 0.093 |
| Categorical-encoding tables | 0.334 (0.020) | 0.550 (0.031) | 0.661 (0.025) | 0.143 | 0.138 | 0.097 |
| Catalogue-fitted tables | 0.388 (—) | 0.486 (—) | 0.542 (—) | 0.316 | 0.308 | 0.211 |
| Nearest catalogue design | 0.034 (—) | 0.137 (—) | 0.268 (—) | — | — | — |
| TPMS designs (128) | ||||||
| Learned tables | 0.378 (0.062) | 0.633 (0.023) | 0.706 (0.008) | 0.132 | 0.120 | 0.098 |
| Categorical-encoding tables | 0.370 (0.055) | 0.646 (0.016) | 0.703 (0.016) | 0.131 | 0.119 | 0.098 |
| Catalogue-fitted tables | 0.578 (—) | 0.711 (—) | 0.750 (—) | 0.133 | 0.119 | 0.098 |
| Nearest catalogue design | 0.000 (—) | 0.039 (—) | 0.203 (—) | — | — | — |
| Strut designs (80) | ||||||
| Learned tables | 0.504 (0.038) | 0.696 (0.050) | 0.754 (0.012) | 0.167 | 0.143 | 0.130 |
| Categorical-encoding tables | 0.592 (0.025) | 0.721 (0.012) | 0.762 (0.000) | 0.167 | 0.141 | 0.129 |
| Catalogue-fitted tables | 0.662 (—) | 0.750 (—) | 0.800 (—) | 0.165 | 0.139 | 0.128 |
| Nearest catalogue design | 0.113 (—) | 0.375 (—) | 0.588 (—) | — | — | — |
| Model | Recall of the true architecture: Rank 3 | Rank 10 | Rank 20 | Held-out RMSE (): | ||
| Blend designs (150) | ||||||
| Learned tables | 0.127 (0.040) | 0.327 (0.020) | 0.673 (0.067) | 0.140 | 0.146 | 0.058 |
| Categorical-encoding tables | 0.167 (0.013) | 0.378 (0.080) | 0.571 (0.053) | 0.140 | 0.151 | 0.072 |
| Catalogue-fitted tables | 0.080 (—) | 0.153 (—) | 0.227 (—) | 0.469 | 0.464 | 0.306 |
| Nearest catalogue design | 0.020 (—) | 0.093 (—) | 0.153 (—) | – | – | – |
| Held-out blend designs whose architecture has no design in the training fold (14) | ||||||
| Learned tables | 0.167 (0.071) | 0.429 (0.000) | 0.690 (0.214) | 0.175 | 0.127 | 0.062 |
| Categorical-encoding tables | 0.119 (0.071) | 0.167 (0.071) | 0.238 (0.071) | 0.123 | 0.117 | 0.067 |
| Catalogue-fitted tables | 0.000 (—) | 0.000 (—) | 0.000 (—) | – | – | – |
| Nearest catalogue design | 0.000 (—) | 0.000 (—) | 0.000 (—) | – | – | – |
Table S8. Five-fold cross-validation on 358 catalogue designs with zero additional simulator calls. Recall at rank is the share of held-out designs whose source architecture is in the first ranks. Entries show means with ranges over three model seeds in parentheses. RMSE is root-mean-square error in log properties. The properties are axial Young’s modulus , Voigt bulk modulus and axial conductivity . Catalogue-fitted tables can predict a held-out design only if its architecture retains another design in the training fold
Figure S1. Offline cross-validated architecture recall. a All 358 catalogue designs. b The 150 blend designs. In five-fold cross-validation, each held-out design’s properties define the target and recall measures whether its source architecture is among the best of 80. Markers show means and bars span three model seeds. Catalogue-fitted tables and nearest-design retrieval are deterministic. This diagnostic uses existing responses and no simulator calls. At ranks three and ten the shared encoding has no recall advantage over categorical encoding. Held-out designs lie on the catalogue grid, so these results describe catalogue-like targets. No setting was selected using this diagnostic
Target construction and resolution change the ordering
The additional sets test how the test-set ordering depends on guaranteed reachability and the particular target draw (Figure 9a). On the fresh draw, learned-table search meets 94 runs, catalogue-table search 87 and three-architecture catalogue search 93. The corresponding mean design errors are 0.01230, 0.01326 and 0.01389. Thus the higher success count than on the test set accompanies a higher mean error. Bracketing search, Bayesian optimisation and Nelder–Mead search meet 87, 84 and 78 runs, and retrieval with pattern search meets 27. The learned-versus-catalogue success difference of 0.065 exceeds the learned seed range of 0.056 on this draw. The paired pooled contrast and confirmatory comparison (Sects. 6.8 and 6.1) distinguish this estimate from evidence on a further draw.
The interpolated targets yield 54 successes each for learned-table and catalogue-table search, compared with 51 for three-architecture catalogue search and four for retrieval with pattern search. For targets defined by the fresh references’ responses, the counts are 65, 66, 69 and 12. The learned-table search’s advantage over catalogue-table search is therefore inconsistent across sets. For all seven configurations in Figure 9a, success falls relative to the fresh draw when the simulator may have no design that matches a target. On the fresh blend targets, 40 of the learned-table search’s 43 successes use an architecture different from the reference, and none returns the reference design. Matching properties can therefore succeed through an alternative architecture. The pure reachable targets largely reduce to architecture identification and one-parameter matching.
A design that meets its target on the search grid can miss at finer resolution. The grid checks show property shifts comparable to or larger than the matching tolerance (Figure 10a,Figure 10b). Over distinct returned test designs, the mean absolute -to- changes in , and are 3.19%, 3.61% and 1.94% for learned-table search, and 3.22%, 3.93% and 1.87% for catalogue-table search. Against the targets, their success counts fall from 84 and 78 to 12 and 18.
Figure 10. Grid-resolution checks. a Fresh-draw designs returned under the 2% stop rule, assessed at 2%, 3% and 5%. Solid lines compare designs and targets on , dashed lines compare the same designs and reference responses on . b Absolute response changes over distinct returned test-set designs. Points show designs with horizontal jitter, bars show means and the dashed line is 2%. Marker shapes and colours identify configurations. These panels measure the 32-to-64 shift, with finer-grid convergence untested
This comparison mixes resolutions on purpose to measure the change from the verified match on the search grid. On the fresh draw, solving both the returned and reference designs at reduces counts from 94 and 87 to 57 and 60. The catalogue-table search is ahead in this finer-grid comparison. No returned design fails validity at . The finer-grid comparison shows that the match can change by more than the tolerance with grid resolution. Convergence at remains untested.
Discussion
Implications for allocating simulations
For a designer who must meet a tight tolerance, a simulation that misses the target can still improve the next proposal. The correction uses the observed properties at the best design to update the table locally. In the matched proposal tests this change improved success for both learned and catalogue-fitted tables (Sect. 6.2). The result connects model management and surrogate alignment ([1, 3]) with the value of a simulation for later design decisions ([24, 8]).
The choice of search depends on the designer’s tolerance and the cost of each call. At 2%, the table-guided searches met more confirmatory targets than the standard optimisers and generally used more calls. At 5%, Bayesian optimisation nearly matched the learned-table search on the test set and fresh draw using fewer than five calls per target (Sects. 6.5 and 6.8). The three-architecture comparison shows that the choice of starting designs also matters when calls are scarce. Because the experiments change ranking, starting designs and allocation together, they estimate the contribution of those decisions as a group (Sect. 6.7). The refinement comparison leaves the separate effects of the two parts of the correction unresolved (Eq. (3)).
These trade-offs arise when the aim is to meet a specification under an allowance ([14]). In a finite library with examples for each architecture and a common verifier, designers can test what a learned model adds by replacing it with catalogue fits while keeping the search and feedback fixed. The comparison gives the designer a basis for choosing between improving the predictor and changing where the search spends calls.
Limits of the benchmark
The test set and fresh-draw targets are generated by library members on the same parameter grid as the search. This construction tests inversion beyond retrieval while excluding impossible targets. For pure architectures it largely tests architecture identification plus one-parameter matching, which helps explain the near-exact strut recovery. Interpolated and finer-grid targets weaken that assumption, but their reachability by the design library is unknown. Their lower success combines search difficulty with potential infeasibility. The test set has 36 targets and three seeds, while the confirmatory set has 200 targets and ten seeds for stochastic arms. The latter still represents one reachable-target generator and one catalogue. The component and sensitivity comparisons on the test set are exploratory. Tests of the same configurations on additional sets show how the results vary with the targets. The comparison arms use the same catalogue, so these comparisons concern search within the common library and information allowance. Learned generators and language-model-guided designers were outside the numerical comparison.
The verifier uses a coarse voxel grid. Targets, catalogue and verifier share one discretisation, so the study leaves search against responses computed by another model untested. Changes in a continuous parameter may leave the geometry unchanged. The finer-grid checks show that a 2% match at cannot be read as convergence or manufactured-property accuracy. The numerical results come from one material system with a fixed base Poisson ratio. Over the 358 catalogue designs, the three log responses have pairwise correlations of 0.92 to 0.98. One principal component accounts for 96% of their variance. The strong correlations in the catalogue limit what this study can say about specifications that trade one property against another. Manufacturing constraints, shear, anisotropy and density requirements were outside the study. The allowance is 30 simulator calls. Training and table construction are paid once per seed for the shared catalogue and excluded from those counts. The Supplementary Information lists the hand-set constants and distinguishes the two varied settings from fixed settings whose values were neither tuned nor sensitivity-tested.
Transfer to other simulators, property sets and libraries remains untested. We recorded the selection rule and its outcome. Individual development runs were incompletely logged, which limits reconstruction of configuration selection. We recorded the confirmatory plan before drawing the targets. It had no external registration. Roughly halving the pure-architecture catalogue did not produce a learned-table advantage (Sect. 6.8), and removing one subset of blend architectures detected no advantage, but more extensive blend hold-outs, larger catalogues and other libraries were not tested. Future work should vary catalogue size and coverage to determine when shared learning adds to per-architecture fitting. A property set with stronger trade-offs and a converged verifier would show whether the same comparison can guide the choice of predictor in a wider range of designs.
Conclusion
With the same search, simulator feedback and call budget, the learned tables and catalogue fits showed no detectable difference in success or design error on the declared comparison. The paired intervals leave smaller benefits or costs unresolved. In separate controls, using simulator feedback to choose the refinement design increased success with both kinds of table. This gives designers with catalogue examples for each architecture and a common verifier a baseline for judging whether a learned model justifies its cost. The comparison can be repeated with other catalogues and property targets to find when learning contributes enough to change that decision.
Supplementary information
The Supplementary Information reports the full search schedule, the Bayesian-optimisation specification, the full ablations, paired contrasts, the correction control for both table types, the catalogue-coverage analyses, per-seed and development outcomes, per-system optimiser comparisons, additional target sets, grid-resolution checks, search constants and offline diagnostics.
Statements and Declarations
Funding This research was supported by the National Science Foundation (NSF) under the Computational and Data-Enabled Science and Engineering (CDS&E) funding opportunity (program description PD 22-8084) [award number 2245299].
Competing interests The authors declare no competing interests.
Author contributions S.Y. designed the study, developed the methods, directed the implementation, experiments and analysis, and wrote and edited the manuscript. J.W. conceptualised the ideas, provided funding, and reviewed and edited the manuscript.
Data availability The offline catalogue, target sets and per-run benchmark results will be available at https://github.com/nbbllxx0/Budgeted-inverse-design-of-periodic-unit-cells.
Code availability The simulator, evaluation protocol, search implementations and analysis scripts will be available at https://github.com/nbbllxx0/Budgeted-inverse-design-of-periodic-unit-cells.
Use of generative AI The authors conceived the study, wrote the manuscript, and take full responsibility for its content and conclusions. OpenAI Codex assisted with editing and formatting. § 4.4 describes assistance with software and analysis. The authors reviewed and revised the AI-assisted work before adopting it.
Supplementary Information
Benchmark construction
The triply periodic minimal surface (TPMS) architectures use eight periodic fields from gyroid, Schwarz P, diamond, I-WP, Neovius, Fischer–Koch S, F-RD and split P. Each has network and sheet constructions. The strut set consists of simple cubic, body-centred cubic, face-centred cubic, octet, body-centred cubic with an added axial member, face-centred cubic with an added axial member, combined simple and body-centred cubic, and diamond truss. The added axial members run along . Each of the 28 level-set pairs has network and sheet constructions.
For the offline catalogue, the pure-architecture grid has ten evenly spaced densities over each system’s design range. Four blend candidates per pair and mode are drawn using weights and densities . After canonicalising the pair order, the generator removes repeated inputs and keeps valid simulator outputs. The catalogue generator uses seed 20261109. The test reference generator uses seed 977. The additional fresh draw uses seed 20261110. Reference densities are drawn uniformly over for pure level-set architectures, for strut architectures and for blends. Reference blend weights are drawn over before canonicalisation. Discrete choices are drawn uniformly within each reference system. Reference designs must be distinct, valid and at least 0.02 in maximum absolute log-ratio error from all catalogue designs.
Table conventions
Learned-table search uses predictions from three feed-forward neural networks and tests up to ten architectures in its first batch. Catalogue-table search uses catalogue-fitted tables under the same schedule. The three-architecture variants open no further architectures after their initial batch. Learned tables for ranking include selection of the starting design, and learned tables for refinement use the model only in queried architectures. Counts pool three seeds per test target. Deterministic configurations give identical repeats, so a dash replaces their seed ranges. Target-level intervals use independent targets as the resampling unit. Calls to success is the index of the first successful query, or 31 if the run never succeeds. The simulator-call count is the number of designs the search queries. Design error is the largest absolute base-10 log-ratio between a returned property and its target, capped at 1. Success means all three simulated properties meet the tolerance stated in the article.
Tables S1 and S2 report the variant results by system. Tables S3 and S4 compare paired outcomes. A boundary interval such as [0.000, 0.000] or [1.000, 1.000] carries no information about performance on new targets. The paired intervals resample targets within their system 20,000 times using seed 0. Both variants and all seeds for a target use the same draw. The tests are two-sided and the reported values are unadjusted. Tables S5–S8 give seed-level results, alternate tolerances, development results and the offline diagnostic. Tables S9–S15 give results by system, search settings, the additional target sets, grid sensitivity and paired comparisons. Table S16 compares corrected and uncorrected refinement proposals for learned and catalogue-fitted tables on the test set, the fresh draw and the confirmatory set. Table S17 compares the two table types under reduced catalogue coverage. Tables S18 and S19 report the degraded and oracle controls and the held-out-architecture test, including simulator calls and zero language-model calls.
Geometry and discretisation
The unit cube is sampled at voxel centres , for on each axis, with for search. Write , , , , , and similarly , . The sampled fields , , , , , , and correspond in order to gyroid, Schwarz P, diamond, I-WP, Neovius, Fischer–Koch S, F-RD and split P.
Each field is divided by its standard deviation over the sampled grid. A blend uses , where and are the two fields of the blend and is the weight on the second field. Network construction uses this signed field, while sheet construction uses its absolute value.
Strut axes are periodically repeated line segments. Denote a segment by , let , , be the Cartesian unit vectors, and . Define the following member sets.
Let be the six face centres, given by
Let contain every unordered pair in with length . For the diamond truss, let
The member sets of the eight topologies are for simple cubic, for body-centred cubic, for face-centred cubic, for octet, for body-centred cubic with an added axial member, for face-centred cubic with an added axial member, for combined simple and body-centred cubic, and for the diamond truss. At each voxel centre , the strut field is the minimum Euclidean distance to a member segment translated by each vector in . The closest point on a segment uses the clipped axial coordinate .
For either a level-set or strut field , sort its samples as . Let , where is the density parameter of the design. Solid voxels satisfy . This threshold is the strut radius for distance fields. Tied samples can change realised density. Continuous design parameters are first rounded to three decimals. Periodic six-neighbour connectivity joins opposite faces, and only the largest component is solved. More than 1% disconnected solid rejects the design.
Periodic trilinear hexahedral elements use two-point Gauss quadrature in each direction. Opposite-face nodal degrees of freedom are identified through periodic indexing. The binary solid mask multiplies the element stiffness and conductivity matrices, giving void zero stiffness and conductivity. Nodes incident to solid elements define the solid-node mask. The solver projects out the mean solid-node displacement in each component, or the mean scalar conduction field, to remove rigid translation or the constant null mode. The Jacobi preconditioner is the reciprocal assembled diagonal where positive and zero elsewhere. The double-precision conjugate gradient solver checks the relative residual every ten iterations at tolerance , with a maximum of 4,000 iterations. The implementation returns the current projected iterate at that cap. A re-solve of the 358 catalogue designs, the 36 fresh-draw and 200 confirmatory reference designs, and the 1,232 distinct designs returned by learned-table and catalogue-table search on the test set, the fresh draw and the confirmatory set comprised 16,434 linear systems. None reached the cap. The largest iteration count was 1,460, and every final relative residual was below . The searches run for Table S16 and their checks solved 101,754 systems. Two of them reached the cap, with final relative residuals of and . The axial screen requires the axial stiffness component , axial Young’s modulus and axial conductivity to be at least in the article’s normalisation. Designs with nonfinite responses or singular stiffness matrices are rejected.
Allocation and response tables
Let be the 2% tolerance on design error. The search is a sequential allocation problem. Let be the set of 80 architectures, the rounded parameter set of architecture , and the offline catalogue. After calls the history is , where is the simulated response of design or an invalidity flag. is the vector of the three target properties. A search policy maps either to the next batch of designs or to a stop, subject to with . The policy then returns one design from its queries and the catalogue. is the design error defined in the article. We compare policies by the success rate and the mean error over targets and seeds, and by the calls they use. Each call either tests an architecture with no valid observation or refines one with a valid observation. This choice determines how the policy allocates calls. The searches in the article are policies of this form.
Each architecture has a table of predicted responses. We train three feed-forward neural networks (multilayer perceptrons, or MLPs) on the offline catalogue. Each table records their average predictions in log space. The shared encoding uses an eight-entry family vector shared across pure TPMS and blends. It assigns one unit entry to a pure family and entries and to the two blend families. A sheet flag, eight strut indicators, three system indicators, and give 22 inputs. Each MLP has three hidden layers of width 128 with the sigmoid linear activation and three response outputs are standardised. Full-batch Adam training (Kingma and Ba, [19]) uses 3,000 steps, initial learning rate 0.003 with cosine decay and weight decay on the weights. These network settings were fixed without tuning.
The pure-architecture grid uses up to 201 density points. It spans the catalogue densities for that architecture plus half the original catalogue spacing on either side, clipped to the design bounds. A blend grid has 101 density points and 41 weight points across the design bounds. These grids are rounded to the design precision. All 80 tables are built before target queries and remain read-only during search.
For the search with catalogue-fitted tables, a pure-architecture table is piecewise linear in with end-segment extrapolation. A blend table is a least-squares plane in fit to that architecture’s catalogue responses. With one design it is constant, with two it has the minimum-norm slope fitting their response difference, and with three or more it uses the least-squares fit, also taking the minimum-norm slope if the fit is underdetermined. An architecture without catalogue observations has no prediction in this variant. The catalogue-table search shares the same table grids, refinement rules and call budget as the learned-table search.
Search schedule of the table-guided searches
This section states the decision rules of the learned-table and catalogue-table searches in full.
The ranking can shift for an entire system after valid observations in three or more architectures. For each property, the shift is the median of the first residuals of those architectures. We omit each architecture in turn and predict its residuals from the others. The shift is used if this prediction reduces the mean of the largest absolute residual across the three properties.
Here is the 2% tolerance on design error, and Table S10 lists the search constants.
First proposals and ranking. For an architecture without a valid observation, the first proposal is the point of its table grid with the lowest predicted error, excluding catalogue designs and the excluded neighbourhoods of invalid queries. Among tied grid points, the one nearest in scaled maximum norm to the architecture’s catalogue design with the lowest target error is taken. Architectures are ordered by this predicted error and then by their position in the library list. The first batch takes the first ten architectures in this order, with at most six from one system.
State. For every architecture the search keeps its valid observations, its invalid queries and a stall counter. The first valid observation in an architecture sets the counter to zero, and so does a valid observation whose error is below the best error observed so far in that architecture. Every other query in the architecture, valid or invalid, adds one. An architecture with two invalid queries and no valid observation receives no further proposal.
Later batches. While the lowest observed error over all architectures is at least , a batch has five designs, or as many as the remaining budget allows. Up to two places open architectures without a valid observation, in the ranking order and without the limit per system. Their tables include the system shift when the leave-one-out check of the article accepts it. The other places hold refinements, one per architecture. A queried architecture is a refinement candidate when it has a proposal, the predicted error of that proposal is below its best observed error, and its stall counter is below three. Candidates are ordered by the predicted error of the proposal when the stall counter is below two, and otherwise by the larger of the predicted and the best observed error. Ties are resolved by the best observed error and then by the library position. Places that one kind of proposal cannot fill pass to the other kind.
Close to the target. Once the lowest observed error is below , every batch has two designs. They are refinements in the two architectures with the lowest best observed errors that still have a proposal. The predicted-improvement test and the stall test do not apply, and no further architecture is opened.
The correction slope is fitted by minimum-norm weighted least squares on the offsets from the current best design, scaled by the parameter ranges. For scaled offset , the least-squares row multiplier is . The relative singular-value cutoff is .
Refinement proposal. Let be the number of valid observations in the architecture. On each parameter axis the window is centred at the best observed design. Its half-width is the larger of times the parameter range and the floor (0.003 in density, 0.01 in blend weight), and it is clipped to the table axis. The window is sampled with the smallest step that is a multiple of 0.001 and may have at most 200 intervals. Catalogue designs and valid observations are excluded. Each invalid query excludes points within a scaled maximum-norm radius of 0.10. When the architecture has valid observations, the radius is capped at half the distance to the nearest one. The proposal minimises the predicted error of the corrected table over the remaining points. A tie goes to the lowest density and then to the lowest weight.
Stop and return. The search stops after a batch that contains a successful query, when no proposal remains or when the budget is spent. It returns the valid observation with the lowest error, or the nearest catalogue design when that design has a strictly lower error.
Controls. The uncorrected-proposal control keeps every rule above, including the candidate tests and orderings that use the corrected prediction. It changes only the queried design, which minimises the uncorrected table over the same window points. The no-residual control takes the same uncorrected proposal, orders refinement candidates by their best observed error, applies only the stall test and uses no system shift.
Bayesian-optimisation comparator
The Gaussian process models the three responses over the architecture , and the blend weight , with for pure architectures. The continuous parameters use a Matérn-5/2 covariance function (Rasmussen and Williams, [26]). For each system and response, the mean is a least-squares line in fitted to the catalogue. For response , the covariance of two designs is
with for the same architecture, for two architectures of one system and otherwise. A nugget is added to the variance of every observation. The three responses share this correlation and are modelled independently, and is the maximum-likelihood variance of response . The hyperparameters maximise the marginal likelihood of the 358 catalogue designs using a limited-memory method for bound-constrained optimisation (L-BFGS-B) (Byrd et al., [5]), with , , and , started at 0.3, 0.3, 0.5, 0.5 and . They are fitted once and held fixed. During a search, the process is conditioned on the catalogue and on the valid observations of the current target.
The incumbent is the lowest error among the catalogue designs and the valid observations. For a candidate with posterior mean and standard deviations , the acquisition is the mean of over 32 standard normal vectors . Here is the vector of log target properties, is elementwise multiplication and takes the largest absolute component. The seed fixes these vectors for all candidates and calls in a run. Each call has two stages. The first stage evaluates every fourth density point and every second weight point of each architecture’s table grid, together with the last point of each axis. The second stage evaluates all designs of the chosen architecture on the 0.001 grid within four density-grid steps and two weight-grid steps of the first-stage choice. Catalogue designs and queried designs are excluded, and an invalid query excludes the designs of its architecture within 0.05 of the parameter range on every axis. If the largest acquisition value is at most , the candidate with the lowest posterior-mean error is taken. Each call queries one design. The search stops at the first successful query or when the budget is spent, and it returns a design by the rule of the table-guided searches.
| Variant | Runs met all (108) | Runs met blend (54) | Design error all | Design error blend | Success rate blend | Calls to success all | Simulator calls per target |
| Reference | |||||||
| Learned-table search | 84 | 32 | 0.00639 (0.00065) | 0.01046 (0.00098) | 0.593 (0.222) | 13.19 (0.22) | 17.03 |
| Learned component | |||||||
| Catalogue-table search | 78 | 24 | 0.00800 (—) | 0.01391 (—) | 0.444 (—) | 13.86 (—) | 17.86 |
| Categorical-encoding search | 79 | 25 | 0.01053 (0.00168) | 0.01904 (0.00350) | 0.463 (0.333) | 14.22 (2.75) | 17.48 |
| Role of the learned tables | |||||||
| Learned tables for ranking only | 84 | 30 | 0.00668 (0.00039) | 0.01167 (0.00085) | 0.556 (0.167) | 13.07 (1.31) | 17.09 |
| Learned tables for refinement only | 80 | 26 | 0.00876 (0.00100) | 0.01526 (0.00208) | 0.481 (0.222) | 13.84 (1.08) | 17.86 |
| Simulator feedback | |||||||
| Uncorrected-proposal control | 65 | 17 | 0.01435 (0.00194) | 0.02457 (0.00366) | 0.315 (0.056) | 15.35 (1.92) | 18.68 |
| No-residual control | 65 | 17 | 0.01375 (0.00249) | 0.02338 (0.00477) | 0.315 (0.056) | 15.35 (1.92) | 18.68 |
| Pattern-search refinement | 59 | 11 | 0.01630 (0.00476) | 0.02872 (0.00749) | 0.204 (0.278) | 16.87 (3.50) | 20.11 |
| Architectures searched | |||||||
| Three architectures with learned tables | 71 | 28 | 0.01377 (0.00408) | 0.02080 (0.01252) | 0.519 (0.056) | 13.81 (0.75) | 13.49 |
| Three-architecture catalogue search | 84 | 30 | 0.01010 (—) | 0.01779 (—) | 0.556 (—) | 9.94 (—) | 10.81 |
| First batch of 3 architectures | 83 | 32 | 0.00686 (0.00063) | 0.01113 (0.00177) | 0.593 (0.167) | 12.34 (1.33) | 13.32 |
| Variant | Runs met all (108) | Runs met blend (54) | Design error all | Design error blend | Success rate blend | Calls to success all | Simulator calls per target |
| First batch of 6 architectures | 87 | 35 | 0.00625 (0.00193) | 0.00995 (0.00311) | 0.648 (0.222) | 12.01 (1.53) | 14.02 |
| First batch of 15 architectures | 79 | 27 | 0.00724 (0.00113) | 0.01216 (0.00336) | 0.500 (0.111) | 14.63 (1.17) | 20.84 |
| Ensemble size | |||||||
| 1 MLP | 80 | 28 | 0.00727 (0.00292) | 0.01266 (0.00609) | 0.519 (0.167) | 14.12 (0.58) | 17.75 |
| 9 MLPs | 82 | 29 | 0.00700 (0.00058) | 0.01175 (0.00177) | 0.537 (0.056) | 12.83 (0.97) | 16.84 |
| Catalogue starts | |||||||
| Pattern-search starts with corrected refinement | 45 | 18 | 0.02049 (—) | 0.02604 (—) | 0.333 (—) | 20.69 (—) | 17.47 |
| Retrieval with pattern search | 23 | 2 | 0.03264 (0.00180) | 0.04489 (0.00357) | 0.037 (0.056) | 26.47 (0.39) | 29.56 |
| Controls | |||||||
| Retrieval control | 0 | 0 | 0.05352 (—) | 0.07027 (—) | 0.000 (—) | 31.00 (—) | 0.00 |
| Random control | 2 | 0 | 0.14299 (0.02949) | 0.18540 (0.05899) | 0.000 (0.000) | 30.76 (0.58) | 30.00 |
Table S1. Component comparisons and sensitivity analyses on the test set. Each variant uses at most 30 simulator calls per target. Metric means are followed by seed ranges in parentheses where shown. A dash denotes a deterministic configuration.
| Variant | TPMS targets (27 runs): Runs met | TPMS targets (27 runs): Design error | TPMS targets (27 runs): Calls to success | Strut targets (27 runs): Runs met | Strut targets (27 runs): Design error | Strut targets (27 runs): Calls to success |
| Reference | ||||||
| Learned-table search | 25 | 0.00463 | 7.37 | 27 | 2.96 | |
| Learned component | ||||||
| Catalogue-table search | 27 | 0.00419 | 4.67 | 27 | 4.33 | |
| Categorical-encoding search | 27 | 0.00405 | 7.56 | 27 | 2.19 | |
| Role of the learned tables | ||||||
| Learned tables for ranking only | 27 | 0.00338 | 5.78 | 27 | 3.52 | |
| Learned tables for refinement only | 27 | 0.00453 | 6.00 | 27 | 3.78 | |
| Simulator feedback | ||||||
| Uncorrected-proposal control | 24 | 0.00542 | 7.74 | 24 | 0.00283 | 5.19 |
| No-residual control | 24 | 0.00542 | 7.74 | 24 | 0.00283 | 5.19 |
| Pattern-search refinement | 23 | 0.00586 | 10.81 | 25 | 0.00189 | 5.04 |
| Architectures searched | ||||||
| Three architectures with learned tables | 20 | 0.00886 | 11.37 | 23 | 0.00464 | 6.04 |
| Three-architecture catalogue search | 27 | 0.00482 | 2.22 | 27 | 2.33 | |
| First batch of 3 architectures | 24 | 0.00516 | 8.44 | 27 | 2.48 | |
| First batch of 6 architectures | 25 | 0.00508 | 7.52 | 27 | 2.52 | |
| First batch of 15 architectures | 25 | 0.00463 | 8.48 | 27 | 3.52 | |
| Ensemble size | ||||||
| 1 MLP | 25 | 0.00378 | 8.00 | 27 | 2.78 | |
| 9 MLPs | 26 | 0.00449 | 6.48 | 27 | 3.04 | |
| Catalogue starts | ||||||
| Pattern-search starts with corrected refinement | 15 | 0.01356 | 15.11 | 12 | 0.01633 | 19.78 |
| Retrieval with pattern search | 9 | 0.02038 | 23.56 | 12 | 0.02040 | 21.22 |
| Controls | ||||||
| Retrieval control | 0 | 0.03111 | 31.00 | 0 | 0.04244 | 31.00 |
| Random control | 0 | 0.08799 | 31.00 | 2 | 0.11318 | 30.04 |
Table S2. Table S2: Component comparisons and sensitivity analyses on TPMS and strut targets. Each system has 27 test runs. TPMS denotes triply periodic minimal surface
| Variant | Runs met all (36) | Runs met blend (18) | Design error all | Design error blend |
| Learned-table search | 27, 26, 31 | 10, 9, 13 | 0.00645, 0.00669, 0.00604 | 0.01004, 0.01103, 0.01033 |
| Variant | Runs met all (36) | Runs met blend (18) | Design error all | Design error blend |
| Catalogue-table search | 26, 26, 26 | 8, 8, 8 | 0.00800, 0.00800, 0.00800 | 0.01391, 0.01391, 0.01391 |
| Categorical-encoding search | 24, 25, 30 | 6, 7, 12 | 0.00948, 0.01116, 0.01095 | 0.01681, 0.02031, 0.01998 |
| Uncorrected-proposal control | 22, 22, 21 | 6, 6, 5 | 0.01342, 0.01427, 0.01536 | 0.02283, 0.02440, 0.02649 |
| Three-architecture catalogue search | 28, 28, 28 | 10, 10, 10 | 0.01010, 0.01010, 0.01010 | 0.01779, 0.01779, 0.01779 |
| First batch of 6 architectures | 28, 27, 32 | 11, 10, 14 | 0.00698, 0.00672, 0.00505 | 0.01104, 0.01087, 0.00794 |
| Retrieval with pattern search | 8, 8, 7 | 1, 1, 0 | 0.03223, 0.03195, 0.03375 | 0.04409, 0.04351, 0.04708 |
| Random control | 1, 1, 0 | 0, 0, 0 | 0.15070, 0.15388, 0.12440 | 0.19539, 0.20991, 0.15091 |
Table S5. Test-set results by seed, in order 0, 1, and 2. Each seed contributes 36 runs, including 18 blend runs. The catalogue-only searches and the retrieval control are deterministic
The offline diagnostic measures recovery of a held-out design’s source architecture. The share recovered in the first ten ranks is 0.519 for learned tables with the shared encoding and 0.550 for categorical-encoding tables across all catalogue designs. On blends, the corresponding values are 0.327 and 0.378. At rank 20 the order reverses for blends (0.673 and 0.571). Held-out root-mean-square errors over all catalogue designs range from 0.093 to 0.144 in log units across responses and the two encodings, well above the tolerance of 0.00860. Figure S1 shows the dependence on shortlist size. The verified search can succeed through any architecture. The offline ranking result leaves the source of the shared encoding’s lower design error unresolved.
| Configuration | Runs met | Success rate | Design error | Calls to success | Simulator calls per target |
| TPMS targets | |||||
| Learned-table search | 25/27 | 0.926 (0.111) [0.778, 1.000] | 0.00463 (0.00220) [0.00237, 0.00787] | 7.37 (0.11) | 12.41 |
| Catalogue-table search | 27/27 | 1.000 (—) [1.000, 1.000] | 0.00419 (—) [0.00277, 0.00561] | 4.67 (—) | 11.22 |
| Bracketing search | 24/27 | 0.889 (—) | 0.00385 (—) | 5.78 (—) | 5.67 |
| Bayesian optimisation | 23/27 | 0.852 (0.111) | 0.00508 (0.00162) | 8.81 (5.67) | 8.67 |
| Nelder–Mead search | 24/27 | 0.889 (—) | 0.00642 (—) | 7.89 (—) | 7.78 |
| Retrieval with pattern search | 9/27 | 0.333 (0.000) [0.000, 0.667] | 0.02038 (0.00000) [0.01086, 0.03142] | 23.56 (0.22) | 30.00 |
| Retrieval control | 0/27 | 0.000 (—) [0.000, 0.000] | 0.03111 (—) [0.02499, 0.03841] | 31.00 (—) | 0.00 |
| Random control | 0/27 | 0.000 (0.000) [0.000, 0.000] | 0.08799 (0.00754) [0.06518, 0.11356] | 31.00 (0.00) | 30.00 |
| Strut targets | |||||
| Learned-table search | 27/27 | 1.000 (0.000) [1.000, 1.000] | (0.00000) [, ] | 2.96 (0.67) | 10.56 |
| Catalogue-table search | 27/27 | 1.000 (—) [1.000, 1.000] | (—) [, ] | 4.33 (—) | 12.22 |
| Bracketing search | 27/27 | 1.000 (—) | (—) | 1.56 (—) | 1.56 |
| Bayesian optimisation | 27/27 | 1.000 (0.000) | (0.00000) | 1.11 (0.00) | 1.11 |
| Nelder–Mead search | 27/27 | 1.000 (—) | (—) | 3.00 (—) | 3.00 |
| Retrieval with pattern search | 12/27 | 0.444 (0.000) [0.111, 0.778] | 0.02040 (0.00009) [0.00709, 0.03467] | 21.22 (0.22) | 29.56 |
| Retrieval control | 0/27 | 0.000 (—) [0.000, 0.000] | 0.04244 (—) [0.03290, 0.05484] | 31.00 (—) | 0.00 |
| Random control | 2/27 | 0.074 (0.111) [0.000, 0.185] | 0.11318 (0.02386) [0.07357, 0.15645] | 30.04 (2.33) | 30.00 |
| Blend targets | |||||
| Learned-table search | 32/54 | 0.593 (0.222) [0.407, 0.778] | 0.01046 (0.00098) [0.00730, 0.01426] | 21.20 (0.61) | 22.57 |
| Catalogue-table search | 24/54 | 0.444 (—) [0.222, 0.667] | 0.01391 (—) [0.00725, 0.02528] | 23.22 (—) | 24.00 |
| Bracketing search | 21/54 | 0.389 (—) | 0.02084 (—) | 21.06 (—) | 20.44 |
| Bayesian optimisation | 21/54 | 0.389 (0.111) | 0.01661 (0.00281) | 25.02 (2.94) | 24.41 |
| Nelder–Mead search | 18/54 | 0.333 (—) | 0.02932 (—) | 24.50 (—) | 23.83 |
| Retrieval with pattern search | 2/54 | 0.037 (0.056) [0.000, 0.111] | 0.04489 (0.00357) [0.02702, 0.06663] | 30.56 (0.67) | 29.33 |
| Retrieval control | 0/54 | 0.000 (—) [0.000, 0.000] | 0.07027 (—) [0.04046, 0.10730] | 31.00 (—) | 0.00 |
| Random control | 0/54 | 0.000 (0.000) [0.000, 0.000] | 0.18540 (0.05899) [0.09822, 0.28935] | 31.00 (0.00) | 30.00 |
Table S9. Table S9: Primary comparison arms by target system. Each TPMS and strut block has 9 targets × three seeds, and the blend block has 18 × three. Means, ranges, intervals and failure convention follow Table 4 of the article. TPMS denotes triply periodic minimal surface
| Setting | Value | Status |
| First-batch architectures | 10 (3, 6, 15 in analysis) | Varied |
| Networks in ensemble | 3 (1, 9 in analysis) | Varied |
| Maximum from one system in first 6 batch | Fixed | |
| Later-batch allocation | 3 refinements and 2 new proposals | Fixed |
| Initial window half-width | One quarter of each parameter range | Fixed |
| Window contraction | Half-width halved per additional valid observation | Fixed |
| Window floors | 0.003 density, 0.01 blend weight | Fixed |
| Close-match switch | Best observed error below | Fixed |
| Architectures refined after switch | Up to 2 | Fixed |
| Release after consecutive misses | 3 | Fixed |
| Drop without valid observation | 2 invalid observations | Fixed |
| Invalid-query exclusion radius | Up to one tenth of the axis span | Fixed |
| System-shift eligibility | At least 3 first valid observations | Fixed |
| System-shift estimate | Componentwise median of first residuals | Fixed |
| System-shift acceptance | Leave-one-out mean maximum residual decreases | Fixed |
| Residual-fit row multiplier | Fixed | |
| Pure-table grid | Up to 201 density points | Fixed |
| Blend-table grid | 101 density × 41 weight points | Fixed |
| Pure-grid extension | Half a catalogue spacing, clipped to bounds | Fixed |
Table S10. Table S10: Search and model constants. Varied entries were sensitivity analyses on the test targets. Fixed values were neither tuned nor sensitivity-tested. The call allowance and success tolerance are benchmark requirements
| Setting | Value | Status |
| Design precision and local grid step | Multiples of 0.001 | Fixed |
| Network hidden layers and width | 3 layers × 128 units | Fixed |
| Training steps and optimizer | 3,000 full-batch Adam steps | Fixed |
| Learning rate and weight decay | 0.003 with cosine decay, | Fixed |
Table S10 (continued).
| Configuration | Met | Met by system | Design error | Success rate (range) | Calls to success | Simulator calls | Met at 3% / 5% |
| Fresh reachable draw | |||||||
| Learned-table search | 94/108 | 24 / 27 / 43 | 0.01230 | 0.870 (0.056) | 10.63 | 14.76 | 99 / 103 |
| Catalogue-table search | 87/108 | 24 / 27 / 36 | 0.01326 | 0.806 (—) | 11.58 | 16.06 | 93 / 102 |
| Three-architecture catalogue search | 93/108 | 21 / 27 / 45 | 0.01389 | 0.861 (—) | 8.67 | 9.56 | 93 / 99 |
| Bracketing search | 87/108 | 24 / 27 / 36 | 0.01121 | 0.806 (—) | 8.83 | 8.64 | 93 / 96 |
| Bayesian optimisation | 84/108 | 23 / 27 / 34 | 0.01337 | 0.778 (0.083) | 11.52 | 11.30 | 94 / 102 |
| Nelder–Mead search | 78/108 | 21 / 27 / 30 | 0.01138 | 0.722 (—) | 15.25 | 14.97 | 78 / 96 |
| Retrieval with pattern search | 27/108 | 12 / 15 / 0 | 0.02891 | 0.250 (0.000) | 26.14 | 29.56 | 37 / 62 |
| Retrieval control | 0/108 | 0 / 0 / 0 | 0.04587 | 0.000 (—) | 31.00 | 0.00 | 0 / 3 |
| Random control | 2/108 | 0 / 2 / 0 | 0.10821 | 0.019 (0.028) | 30.95 | 30.00 | 5 / 9 |
| Pattern-search starts with corrected refinement | 45/108 | 15 / 18 / 12 | 0.01973 | 0.417 (—) | 21.61 | 18.50 | 54 / 90 |
| Interpolated responses | |||||||
| Learned-table search | 54/108 | 16 / 9 / 29 | 0.01758 | 0.500 (0.139) | 22.23 | 23.02 | 67 / 84 |
| Catalogue-table search | 54/108 | 12 / 12 / 30 | 0.02117 | 0.500 (—) | 22.72 | 23.53 | 66 / 84 |
| Three-architecture catalogue search | 51/108 | 9 / 12 / 30 | 0.01768 | 0.472 (—) | 20.89 | 20.69 | 75 / 90 |
| Bracketing search | 39/108 | 12 / 9 / 18 | 0.01743 | 0.361 (—) | 21.50 | 20.86 | 57 / 87 |
| Bayesian optimisation | 39/108 | 10 / 9 / 20 | 0.01771 | 0.361 (0.222) | 24.65 | 24.01 | 57 / 85 |
| Nelder–Mead search | 18/108 | 3 / 9 / 6 | 0.02406 | 0.167 (—) | 27.47 | 26.64 | 45 / 78 |
| Retrieval with pattern search | 4/108 | 0 / 3 / 1 | 0.03787 | 0.037 (0.028) | 30.44 | 29.78 | 13 / 36 |
| Retrieval control | 0/108 | 0 / 0 / 0 | 0.05321 | 0.000 (—) | 31.00 | 0.00 | 0 / 3 |
| Random control | 0/108 | 0 / 0 / 0 | 0.13079 | 0.000 (0.000) | 31.00 | 30.00 | 0 / 3 |
| Pattern-search starts with corrected refinement | 27/108 | 6 / 6 / 15 | 0.02387 | 0.250 (—) | 26.06 | 22.17 | 36 / 63 |
| Fresh-reference 64³ responses | |||||||
| Learned-table search | 65/108 | 15 / 11 / 39 | 0.02060 | 0.602 (0.083) | 18.01 | 19.75 | 84 / 98 |
| Catalogue-table search | 66/108 | 15 / 12 / 39 | 0.01661 | 0.611 (—) | 18.83 | 20.11 | 81 / 96 |
| Three-architecture catalogue search | 69/108 | 15 / 15 / 39 | 0.02103 | 0.639 (—) | 15.28 | 14.11 | 84 / 96 |
| Bracketing search | 60/108 | 15 / 15 / 30 | 0.01763 | 0.556 (—) | 17.47 | 17.03 | 78 / 93 |
| Bayesian optimisation | 52/108 | 13 / 6 / 33 | 0.01751 | 0.481 (0.083) | 20.36 | 19.84 | 82 / 95 |
| Nelder–Mead search | 48/108 | 12 / 12 / 24 | 0.01690 | 0.444 (—) | 22.19 | 21.64 | 66 / 87 |
| Retrieval with pattern search | 12/108 | 6 / 3 / 3 | 0.03118 | 0.111 (0.000) | 28.29 | 29.44 | 30 / 64 |
| Retrieval control | 0/108 | 0 / 0 / 0 | 0.04536 | 0.000 (—) | 31.00 | 0.00 | 3 / 15 |
| Random control | 1/108 | 1 / 0 / 0 | 0.10301 | 0.009 (0.028) | 30.80 | 30.00 | 1 / 6 |
| Pattern-search starts with corrected refinement | 27/108 | 12 / 3 / 12 | 0.02433 | 0.250 (—) | 25.31 | 20.47 | 51 / 72 |
Table S11. Table S11: Unchanged configurations on additional sets, each 36 targets × three seeds and at most 30 search calls per target. System counts are TPMS / strut / blend (out of 27 / 27 / 54). Searches use responses for every set. The last column re-scores returned designs under the 2% stop rule. Ranges describe seed sensitivity and dashes denote deterministic configurations. Deterministic targets met out of 36 equal the reported runs met divided by three. All configurations use zero language-model calls. TPMS denotes triply periodic minimal surface
| Configuration | Designs | Mean absolute property shift (%) | Test 32^3 | Test 64^3 vs 32^3 | Fresh 32^3 | Fresh 64^3 |
| Learned-table search | 79 | 3.19 | 84 | 12 | 94 | 57 |
| 3.61 | 94 | 41 | 99 | 72 | ||
| 1.94 | 100 | 64 | 103 | 91 | ||
| Catalogue-table search | 35 | 3.22 | 78 | 18 | 87 | 60 |
| 3.93 | 99 | 33 | 93 | 72 | ||
| 1.87 | 105 | 66 | 102 | 90 | ||
| Retrieval with pattern search | 42 | 3.70 | 23 | 11 | 27 | 9 |
| 3.59 | 29 | 11 | 37 | 25 | ||
| 2.45 | 46 | 35 | 62 | 52 |
Table S12. Resolution checks without further search. Mean absolute property shifts (percent) use distinct returned test geometries and are ordered top to bottom as axial Young’s modulus , Voigt bulk modulus and axial conductivity . Count columns give, from top to bottom, 2% / 3% / 5% matches out of 108. Test-set targets remain at for both returned-design evaluations. Fresh-set references and returned designs are evaluated at the same grid. No returned design is invalid at . Convergence of is untested.
Pooling the 72 reachable targets of the test set and fresh draw gives a success-rate difference of 0.060 [0.009, 0.116], including a blend difference of 0.139 [0.037, 0.250]. The overall sign test counts 11 targets better, four worse and 57 tied (). The pooled mean design-error difference is −0.00128 [−0.00358, 0.00023], and calls to success differ by −0.81 [−2.29, 0.59]. Thus the pooled success-rate interval favours this learned model, while the error and calls intervals include zero. These contrasts are post hoc and unadjusted for multiplicity, and the learned configuration had passed a development screen against the same comparator (see the article’s benchmark comparisons), which can bias a smaller-set estimate upward. The pooled blend estimate of 0.139 lies above the confirmatory blend interval, while the pooled interval [0.037, 0.250] overlaps that interval. The confirmatory interval includes zero and its upper limit is below the pooled estimate. The confirmatory comparison therefore leaves a smaller effect unresolved. Table S13 gives the paired outcomes for the additional sets.
| System | Met / runs | Success [95% interval] | Design error | Calls to success | Simulator calls |
| Learned-table search | |||||
| All | 1687/2000 | 0.844 [0.804, 0.881] | 0.00669 | 10.82 | 15.27 |
| TPMS | 494/500 | 0.988 [0.964, 1.000] | 0.00343 | 5.64 | 11.33 |
| Strut | 490/500 | 0.980 [0.942, 1.000] | 0.00063 | 3.27 | 10.85 |
| Blend | 703/1000 | 0.703 [0.626, 0.776] | 0.01135 | 17.18 | 19.46 |
| Catalogue-table search | |||||
| All | 167/200 | 0.835 [0.785, 0.880] | 0.00667 | 10.61 | 15.43 |
| TPMS | 49/50 | 0.980 [0.940, 1.000] | 0.00376 | 4.96 | 11.90 |
| Strut | 50/50 | 1.000 [1.000, 1.000] | 0.00041 | 3.14 | 10.92 |
| Blend | 68/100 | 0.680 [0.590, 0.770] | 0.01127 | 17.17 | 19.44 |
| Three-architecture catalogue search | |||||
| All | 170/200 | 0.850 [0.800, 0.895] | 0.00745 | 8.40 | 9.05 |
| TPMS | 48/50 | 0.960 [0.900, 1.000] | 0.00536 | 3.24 | 3.72 |
| Strut | 49/50 | 0.980 [0.940, 1.000] | 0.00181 | 2.42 | 3.96 |
| Blend | 73/100 | 0.730 [0.640, 0.810] | 0.01132 | 13.97 | 14.26 |
| Bracketing search | |||||
| All | 157/200 | 0.785 [0.735, 0.835] | 0.00820 | 9.53 | 9.31 |
| TPMS | 50/50 | 1.000 [1.000, 1.000] | 0.00343 | 2.78 | 2.78 |
| Strut | 50/50 | 1.000 [1.000, 1.000] | 0.00067 | 2.02 | 2.02 |
| System | Met / runs | Success [95% interval] | Design error | Calls to success | Simulator calls |
| Blend | 57/100 | 0.570 [0.470, 0.660] | 0.01435 | 16.66 | 16.23 |
| Bayesian optimisation | |||||
| All | 1446/2000 | 0.723 [0.682, 0.764] | 0.00779 | 12.29 | 12.02 |
| TPMS | 445/500 | 0.890 [0.810, 0.956] | 0.00512 | 5.98 | 5.87 |
| Strut | 498/500 | 0.996 [0.990, 1.000] | 0.00077 | 2.36 | 2.35 |
| Blend | 503/1000 | 0.503 [0.428, 0.578] | 0.01264 | 20.42 | 19.92 |
| Nelder–Mead search | |||||
| All | 143/200 | 0.715 [0.665, 0.765] | 0.00928 | 14.15 | 13.87 |
| TPMS | 48/50 | 0.960 [0.900, 1.000] | 0.00419 | 6.38 | 6.34 |
| Strut | 49/50 | 0.980 [0.940, 1.000] | 0.00194 | 5.38 | 5.36 |
| Blend | 46/100 | 0.460 [0.360, 0.560] | 0.01550 | 22.43 | 21.89 |
| Retrieval with pattern search | |||||
| All | 545/2000 | 0.273 [0.225, 0.320] | 0.02313 | 25.73 | 29.48 |
| TPMS | 180/500 | 0.360 [0.220, 0.500] | 0.01587 | 23.79 | 29.28 |
| Strut | 340/500 | 0.680 [0.540, 0.800] | 0.00938 | 17.69 | 29.68 |
| Blend | 25/1000 | 0.025 [0.000, 0.060] | 0.03363 | 30.72 | 29.48 |
Table S14. Confirmatory results by system. Stochastic configurations use ten seeds. Deterministic configurations count each target once after identical two-seed runs. Success intervals bootstrap targets. Means include failures at 31 calls to success. All configurations use at most 30 simulator calls per target and zero language-model calls.
Table S15: Confirmatory paired contrasts, formatted as in Table S13. The primary contrast is learned-table minus catalogue-table search, with success and design error overall and on blends as four declared endpoints. Other contrasts and calls are descriptive. All intervals and tests are unadjusted for multiplicity. Boundary intervals carry no information about new targets. Simulator allowance is 30 per target and language-model calls are zero.
The two added coverage analyses ask whether a sparser catalogue would change the confirmatory result (Table S17). Among the 100 confirmatory blend targets, the learned-minus-catalogue success difference is 0.037 [−0.050, 0.143] for the 30 targets whose reference architecture has one or two catalogue designs. It is 0.010 [−0.080, 0.102] for the 49 targets with three designs and 0.033 [−0.171, 0.238] for the 21 targets with four. With the thinned catalogue, learned-table search meets 493 of 600 runs and catalogue-table search meets 163 of 200 targets. The difference is 0.007 [−0.032, 0.047] overall and 0.033 [−0.033, 0.103] on blends. Neither analysis detects a learned-table advantage. The thinning roughly halves the pure-architecture catalogue and leaves the blend catalogue unchanged, so it does not test sparser blend coverage.
Additional checks on the confirmatory targets
On the same 200 confirmatory targets, we test whether search outcomes respond to large changes in table quality and whether learning helps when the catalogue omits architectures. We first reran the 2,400 original learned-table and catalogue-table runs and obtained identical outcomes. These controls keep the search, 30-call budget and 2% stop rule fixed.
The degraded table uses one least-squares line per system to predict log responses from log density. It gives all architectures in a system the same prediction at a given density. The oracle table interpolates simulator responses on a coarse grid with 21 densities per pure architecture and 11 densities by nine weights per blend architecture. Constructing it used 6,048 simulator calls outside every search budget, including 4,767 newly solved designs and 1,281 served from the solver cache; 1,238 designs were rejected. Only the oracle uses these extra simulations.
The held-out-architecture test removes all 38 catalogue designs of one randomly chosen subset of 14 blend architectures, leaving 320 designs, and rebuilds both table types. Catalogue tables give no prediction for the removed architectures. Learned-table controls use seeds 0–2. Deterministic configurations count once per target. We planned these controls after seeing the confirmatory results and before running the controls. Tables S18 and S19 report the outcomes and paired target-bootstrap intervals.
References
- [1]Alexandrov, N., Dennis, J., Lewis, R., & al, . et . (1998). A trust-region framework for managing the use of approximation models in optimization. Structural Optimization, 15(1), 16–23. https://doi.org/10.1007/BF01197433
- [2]Alizadeh R, Allen JK, Mistree F (2020) Managing computational complexity using surrogate models: a critical review. Research in Engineering Design 31(3):275–298. https://doi.org/10.1007/s00163-020-00336-7
- [3]Bandler, J., Cheng, Q., Dakroury, S., & al, . et . (2004). Space mapping: The state of the art. IEEE Transactions on Microwave Theory and Techniques, 52(1), 337–361. https://doi.org/10.1109/tmtt.2003.820904
- [4]Bastek, J., Kumar, S., Telgen, B., & al, . et . (2022). Inverting the structure–property map of truss metamaterials by deep learning. Proceedings of the National Academy of Sciences, 119(1), e2111505119. https://doi.org/10.1073/pnas.2111505119
- [5]Byrd, R., Lu, P., Nocedal, J., & al, . et . (1995). A limited memory algorithm for bound constrained optimization. SIAM Journal on Scientific Computing, 16(5), 1190–1208. https://doi.org/10.1137/0916069
- [6]Carpentier A, Locatelli A (2016) Tight (lower) bounds for the fixed budget best arm identification bandit problem. In: 29th Annual Conference on Learning Theory, Proceedings of Machine Learning Research, vol 49. PMLR, pp 590–604, URL https://proceedings.mlr.press/v49/carpentier16.htmlproceedings.mlr.press/v49/carpentier16.html
- [7]Chan, Y., Ahmed, F., Wang, L., & al, . et . (2021). Metaset: Exploring shape and property spaces for data-driven metamaterials design. Journal of Mechanical Design, 143(3), 031707. https://doi.org/10.1115/1.4048629
- [8]Chaudhari AM, Bilionis I, Panchal JH (2020) Descriptive models of sequential decisions in engineering design: An experimental study. Journal of Mechanical Design 142(8):081704. https://doi.org/10.1115/1.4045605
- [9]Chen, C., Lin, J., Yücesan, E., & al, . et . (2000). Simulation budget allocation for further enhancing the efficiency of ordinal optimization. Discrete Event Dynamic Systems, 10(3), 251–270. https://doi.org/10.1023/a:1008349927281
- [10]Chen, R., Zhang, W., Jia, Y., & al, . et . (2024). Ultra-stiff and quasi-elastic-isotropic triply periodic minimal surface structures designed by deep learning. Materials & Design, 244, 113107. https://doi.org/10.1016/j.matdes.2024.113107
- [11]Danesh H, Wessels H (2026) Data-efficient bayesian-guided design selection from large candidate sets: Application to hyperelastic stochastic metamaterials. Materials & Design 270:116984. https://doi.org/10.1016/j.matdes.2026.116984
- [12]Dowell M, Jarratt P (1971) A modified regula falsi method for computing the root of an equation. BIT 11(2):168–174. https://doi.org/10.1007/BF01934364
- [13]Efron B (1979) Bootstrap methods: Another look at the jackknife. The Annals of Statistics 7(1):1–26. https://doi.org/10.1214/aos/1176344552
- [14]Guo L, Allen JK, Mistree F (2024) Optimize or satisfice in engineering design? Research in Engineering Design 35:239–267. https://doi.org/10.1007/s00163-023-00431-5
- [15]Jiang, S., Wu, J., Schroeder, C., & al, . et . (2026). Range-aware bayesian optimization for discovering diverse designs within target property windows. Digital Discovery, 5(9), 3674–3693. https://doi.org/10.1039/d6dd00358c
- [16]Jones DR, Schonlau M, Welch WJ (1998) Efficient global optimization of expensive black-box functions. Journal of Global Optimization 13(4):455–492. https://doi.org/10.1023/a:1008064311147
- [17]Kennedy MC, O’Hagan A (2000) Predicting the output from a complex computer code when fast approximations are available. Biometrika 87(1):1–13. https://doi.org/10.1093/biomet/87.1.1
- [18]Keshav S, Fritzen F (2026) Robust inverse material design with physical guarantees using the Voigt–Reuss net. International Journal for Numerical Methods in Engineering 127(7):e70296. https://doi.org/10.1002/nme.70296
- [19]Kingma DP, Ba J (2015) Adam: A method for stochastic optimization. In: International Conference on Learning Representations, URL https://arxiv.org/abs/1412.6980
- [20]Lee, D., Chan, Y., Chen, W., & al, . et . (2023). t-metaset: Task-aware acquisition of metamaterial datasets through diversity-based active learning. Journal of Mechanical Design, 145(3), 031704. https://doi.org/10.1115/1.4055925
- [21]Lee, D., Chen, W., Wang, L., & al, . et . (2024). Data-driven design for metamaterials and multiscale systems: A review. Advanced Materials, 36(8), 2305254. https://doi.org/10.1002/adma.202305254
- [22]Lookman, T., Balachandran, P., Xue, D., & al, . et . (2019). Active learning in materials science with emphasis on adaptive sampling using uncertainties for targeted design. Npj Computational Materials, 5(1), 21. https://doi.org/10.1038
- [23]Nelder JA, Mead R (1965) A simplex method for function minimization. The Computer Journal 7(4):308–313. https://doi.org/10.1093/comjnl/7.4.308
- [24]Panchal, J. H., Paredis, C. J. J., Allen, J. K., & al, . et . (2009). Managing design-process complexity: A value-of-information based approach for scale and decision decoupling. Journal of Computing and Information Science in Engineering, 9(2), 021005. https://doi.org/10.1115/1.3130791
- [25]Peherstorfer B, Willcox K, Gunzburger M (2018) Survey of multifidelity methods in uncertainty propagation, inference, and optimization. SIAM Review 60(3):550–591. https://doi.org/10.1137/16m1082469
- [26]Rasmussen CE, Williams CKI (2006) Gaussian Processes for Machine Learning. MIT Press, URL https://gaussianprocess.org/gpml/chapters/DOI
- [27]Regenwetter L, Nobari AH, Ahmed F (2022) Deep generative models in engineering design: A review. Journal of Mechanical Design 144(7):071704. https://doi.org/10.1115/1.4053859
- [28]Schumacher, C., Bickel, B., Rys, J., & al, . et . (2015). Microstructures to control elasticity in 3D printing. ACM Transactions on Graphics, 34(4), 136:1–136:13. https://doi.org/10.1145/2766926
- [29]Sigmund O (1994) Materials with prescribed constitutive parameters: An inverse homogenization problem. International Journal of Solids and Structures 31(17):2313–2329. https://doi.org/10.1016/0020-7683(94)90154-6
- [30]Trabucco, B., Geng, X., Kumar, A., & al, . et . (2022). Design-Bench: Benchmarks for data-driven offline model-based optimization. Proceedings of the 39th International Conference on Machine Learning, Proceedings of Machine Learning Research, 162, 21658–21676. https://proceedings.mlr.press/v162/trabucco22a.htmlproceedings.mlr.press/v162/trabucco22a.html
- [31]Viana, F. A. C., Simpson, T. W., Balabanov, V., & al, . et . (2014). Special section on multidisciplinary design optimization: Metamodeling in multidisciplinary design optimization: How far have we really come?. AIAA Journal, 52(4), 670–690. https://doi.org/10.2514/1.j052375
- [32]Wang, L., Chan, Y. C., Ahmed, F., & al, . et . (2020). Deep generative modeling for mechanistic-based learning and design of metamaterial systems. Computer Methods in Applied Mechanics and Engineering, 372, 113377. https://doi.org/10.1016/j.cma.2020.113377
- [33]Wang, L., Tao, S., Zhu, P., & al, . et . (2021). Data-driven topology optimization with multiclass microstructures using latent variable Gaussian process. Journal of Mechanical Design, 143(3), 031708. https://doi.org/10.1115/1.4048628
- [34]Wilcoxon F (1945) Individual comparisons by ranking methods. Biometrics Bulletin 1(6):80–83. https://doi.org/10.2307/3001968
- [35]Zheng, L., Karapiperis, K., Kumar, S., & al, . et . (2023). Unifying the design space and optimizing linear and nonlinear truss metamaterials by generative modeling. Nature Communications, 14(1), 7563. https://doi.org/10.1038/s41467-023-42068-x








