Structural mechanics / numerical evaluation

The question

If two structures are “close”, they should behave similarly under loads you have not tested yet. This experiment asked whether a local geometry induced by response sensitivities — a Jacobian pullback built from exact derivatives of the displacement field — captures that behavioural similarity better than simpler distance measures.

Design

• System: linear six-degree-of-freedom spring networks with fixed topology. Stiffness is assembled from log-stiffnesses $\theta$ and the response follows from $K u = f$:

The derivative is exact for this model and is checked against central differences in unit tests. The local geometry averages $J^{\top} J$ over the training loads, giving a positive semidefinite tensor $M(\theta)$.

• Data: five independent generator seeds, each producing 120 training, 50 development and 60 test stiffness configurations with independently sampled load banks.
• Oracle: RMS displacement difference under test loads only, never seen during fitting or selection.
• Preregistration: the decision rule and a meaningful-gain threshold of +0.02 Spearman were frozen in a protocol before the run. A hash lock on configuration, source, splits, development results and protocol was verified before any test response was computed.
• Comparators: Euclidean, standardised Euclidean, global Mahalanobis, global sensitivity and a direct response-profile distance, plus scrambled and permuted controls.

The core computation solves for every load and every spring in one batched linear solve, after the operator has been checked for symmetry and positive definiteness:

def response_and_jacobian(theta, loads, b=B):
    """Return u and du/dtheta for every load; Jacobian shape is (load, dof, edge).

    dK/dtheta_e = k_e b_e b_e.T and du/dtheta_e = -K^-1 (dK/dtheta_e) u.
    """
    f = np.atleast_2d(np.asarray(loads, dtype=float))
    k_matrix = stiffness(theta, b)
    u, min_eigenvalue, condition = checked_solve(k_matrix, f)
    spring_k = np.exp(theta)
    extensions = u @ b.T  # (load, edge)
    rhs = -spring_k[None, None, :] * extensions[:, None, :] * b.T[None, :, :]
    n_load, n_dof, n_edge = rhs.shape
    packed = rhs.transpose(1, 0, 2).reshape(n_dof, n_load * n_edge)
    jac = np.linalg.solve(k_matrix, packed).reshape(n_dof, n_load, n_edge).transpose(1, 0, 2)
    return u, jac, min_eigenvalue, condition

Results

Decision: not supported. The local pullback scored a mean test Spearman of 0.987 against 0.998 for the strongest simple baseline. The difference was −0.011, with a hierarchical 95% interval of [−0.016, −0.009] — the wrong side of the +0.02 threshold, on every seed.

The local geometry did carry real information — it far outperformed generic distances and its scrambled-coordinate control (gap 0.579). It just did not beat a well-chosen simple baseline.

Why the baseline won

In this linear setting the exact simulator is available, and training and test loads come from the same distribution. The squared response-profile distance is then exactly

with $C$ the empirical mean of $f f^{\top}$ over the load bank — so the “simple” baseline is already estimating almost exactly what the oracle measures. A follow-up audit traced the failure to this mechanism: the training load bank determines each structure’s compliance well enough that a first-order local approximation has nothing left to add.

Rigor and limits

• A fresh rerun from a clean directory passed all unit tests and reproduced every split hash, the selected baseline, the primary estimate, the interval and the decision.
• Numerically stable throughout: no non-finite distances; largest spectral condition number 70.5.