What class of scoring functions can this engine minimise exactly, and is the scoring function's form — or its parameterisation — the thing holding accuracy back? Two theorems — both now built and verified — five measurements, and two negatives.
The repo has closed the search side and said so: the torsion factor is provably optimal (125/125 verified), the discretisation it searches over is not the limit either, and both results are accuracy-neutral on SPINDR. Meanwhile the pool holds a near-native pose for 97.5% of targets and top-1 selects one 62% of the time. The remaining gap is scoring.
The received view of what scoring can be is stated in src/learned_field.rs and
DOCKING_AS_INFERENCE.md §3.8:
and the risk register names the corresponding fatal risk: "additivity over ligand atoms is the binding constraint." The additive-field gate ran to test it and returned INCONCLUSIVE — 49.5% CV against Vinardo's 52.1%, still climbing on the learning curve at the corpus limit.
Both halves of that turn out to be wrong, in opposite directions. The quoted constraint is not the real constraint — a strictly larger class is exactly searchable. And additivity is not what made the gate fail — the parameterisation is, and 74 parameters fix it.
Theorem 1. An arbitrary nonlinearity applied after the pooled sum preserves exhaustive translational optimality.
Let Φ₁…Φ_P be any receptor scalar fields on the grid, u_p(a) any per-class weights, and define the pooled channels
Then for any function f: R^P → R — non-additive, non-monotone, non-convex, a neural network —
is computed exactly, over the complete translation lattice, at the cost of the P correlations plus one pointwise pass of f over a volume the engine already materialises.
Trilinear interpolation is a linear operator: for any x there is a sparse weight row I_x with ≤ 8 nonzeros summing to 1 such that the interpolated value is I_x Φ. Hence
a discrete cross-correlation of the fixed field Φ_p against the ligand's
trilinear scatter ρ_p — exactly the operation correlate.rs already
performs, and exact at every lattice translation. So the vector
(S_1(t),…,S_P(t)) is available at every t
simultaneously. Evaluating f at each lattice point is then a pointwise map,
and the minimum of a function tabulated at every point of a finite set is exact. ∎
correlate.rs already documents the opposite case and prices it: the engine's own
per-atom curl e·v/(v+e) applied after interpolation "means the sum is no
longer a convolution", so correlate_exact pays one evaluation per (atom, translation)
pair. That is right, and it is the general fact — a nonlinearity inside the sum does not
commute with interpolation, so folding it into the map nodes (MapTransform::Curl)
costs an O(h²) commutation error.
Theorem 1 sits on the other side of the sum. f is applied to S_p(t), a scalar that the correlation computes exactly, so there is no commutation error at all. The pooled nonlinearity is both strictly more expressive than the additive class and strictly better behaved than the per-atom one.
It is worth being precise rather than declaring the CNN impossible. The hierarchy is one of cost, and the boundary is the receptive field:
| scoring form | whole-lattice cost | exact? |
|---|---|---|
| additive, Σᵢ Φ(xᵢ) | |Λ| log|Λ| · P | yes |
| pooled nonlinear, f(S₁…S_P) | |Λ| log|Λ| · P + |Λ|·cost(f) | yes |
| per-atom nonlinear, Σᵢ ψ(Φ(xᵢ)) | |Λ| log|Λ| · P | O(h²) commutation |
| joint voxel CNN, depth 1 | |Λ| · |supp ρ| | yes, ~10³× dearer |
| joint voxel CNN, depth L | |Λ| · (full forward pass) | infeasible |
A depth-1 joint CNN Σ_v σ(A_v + ρ(v−t)) is exhaustively
computable — it is the correlate_exact regime. What kills depth is the receptive
field: after L convolutions of kernel k the
ligand's influence has dilated by L(k−1)/2 voxels, and for GNINA's
geometry that is the whole box, so the per-translation cost becomes a full forward pass.
The CNN is confined to a retained pool by receptive-field growth, not by non-additivity —
and a model built as deep receptor encoder → per-atom readout → pooled head escapes the
confinement entirely, because all of its depth sits on the receptor side, where it is amortised.
pipeline.rs:739 calls correlate, gets a TranslationField
with a full values: Vec<f32>, and hands it to local_minima(top_k).
The change is: produce P accumulators instead of one, then fuse them with
f into a single TranslationField before
local_minima. Everything downstream — top-M retention, torsion resolution, L-BFGS,
clustering, determinism — is untouched. Gradients survive too:
∇E = Σ_p (∂f/∂S_p) ∇S_p, so refinement costs one extra grid gradient per
channel.
The cost is honest and bounded: P scatter-accumulate passes per atom instead of one, and P fields resident instead of one. The channels cannot be collapsed here — that is exactly what the nonlinearity forbids — so this is a real P× on the correlation step, and the reason to keep P small.
Built and verified.
correlate::correlate_channels and correlate::fuse. Three tests carry
the theorem: every channel field matches an independent atom-major readout at every
lattice point; the argmin of a deliberately non-additive, non-monotone, non-convex head
(tanh + sin) matches brute force over the whole window; and one linear
channel is bit-identical to correlate — so the new path contains
the old one exactly rather than approximating it. Full suite: 285 tests, 0 failures.
Theorem 1 covers translation (materialised) and rotation (enumerated). Torsions are the factor
that a nonlinear head appears to break, because TorsionSolver::resolve_exact needs an
objective additive over the kinematic tree. It does not break, provided the head is built
monotone.
Theorem 2. If S: Ω^n → R^P is tree-additive and f is coordinatewise non-decreasing, then the exact global minimum of f∘S over the discrete torsion product space is returned by A* whose heuristic is the existing DP's own messages.
For a partial assignment α of a root-path prefix, let m_p(α) = min over completions of S_p — which is precisely the completion-cost message the additive DP already computes, one pass per channel. Then
is admissible: every completion τ has S_p(τ) ≥ m_p(α) componentwise, and monotone f preserves the inequality. It is also consistent: extending α only shrinks the completion set, so each m_p is non-decreasing along a path and f carries that through. Consistent + admissible ⇒ A* expands each node once and terminates with a proof. Cost: P DP passes, then best-first search. ∎
Two refinements, in increasing order of effort:
Design rule. Make the head monotone by construction — non-negative weights on the pass-through path. Monotone and convex is the input-convex network of Amos, Xu & Kolter, which buys both refinements at once. Convexity in the pooled channels is also the physically natural side: saturating reward is convex energy. Cooperativity is the concave case and is the one you give up.
Built and verified against brute force.
src/monotone_head.rs. A* matches exhaustive enumeration of the product space on
40 random trees, and the returned assignment reproduces the returned value.
Admissibility is checked directly at 200 random prefixes — the bound
never exceeds the best completion of the same prefix. P = 1 with
f the identity reproduces plain min-sum.
And the heuristic prunes hard, improving as the tree grows: at 10 nodes × 3 states it expands 17 of a 59,049-assignment product space (0.03%), against 4.94% at 4 nodes. Exceeding the expansion budget returns the incumbent with proven_optimal: false — never a wrong answer presented as a right one.
| head | translation | rotation | torsion |
|---|---|---|---|
| linear (today) | exact | exact | exact, proved 125/125 |
| monotone nonlinear | exact | exact | exact via A* |
| monotone + convex | exact | exact | exact, tighter bound |
| arbitrary, P ≤ 3 | exact | exact | exact, and exact Z |
| arbitrary, large P | exact | exact | bound only |
This is the result that changes what to build. It began as a check on §1's premise and ended somewhere else.
The additive gate fits a free tensor W[ligand class, receptor class, radial knot] — 12 × 10 × 15 = 1800 parameters, the most general pairwise-additive form at that resolution. But every classical force field asserts that this tensor is low-rank, and says so through its combining rules:
A CP factorisation W[a,b,k] = Σ_p u_p[a]·v_p[b]·g_p[k] is exactly the statement that a combining rule exists, with the rule learned rather than assumed. And it is simultaneously a statement about search cost, because it turns the intermolecular term into
where u_p is a learned atom-type embedding and P is its width. Rank is the parameter budget and the inductive bias at once.
And under a linear head the rank constraint is free at inference.
The channels can be pre-composed back into one map per ligand class before docking —
Φ̃_a(x) = Σ_p u_p[a]·Φ_p(x) — so a CP field drops into
ReceptorGrids::build_learned's existing slot with identical runtime, identical
map count, and identical correlation cost to the free tensor. The rank restriction is purely
statistical: it costs nothing and buys the whole of M4.
The P channels only have to stay separate when the head is nonlinear (§1), because that is precisely when they cannot be summed early. So P is one dial with two regimes: free today, and the width of the nonlinear head tomorrow.
M1 — Additivity is not the binding constraint.
With the regulariser switched off, the additive class ranks its own training pools perfectly: 158/158 in-sample top-1 and 0 of 6,162 ranking constraints violated, in 1,800 dimensions. The constraint system is over-determined 3.4×, so this is not automatic. A class that shatters its training set is not the thing that is failing — the risk register's fatal risk does not fire. The failure is entirely generalisation.
M2 — The incumbent potential is near rank one.
Refit Vina/Vinardo into the same free basis (within-target R² = 0.92) and take its HOSVD: the leading factor holds 92.6% / 92.7% / 94.1% of the energy in the three modes. CP rank 8 reconstructs it to 4.9% relative error using 296 of 1,800 parameters.
Honest reading: the incumbent is low-rank partly by construction, so this shows the rank-P basis contains the incumbent at small P — a necessary condition — not that the true potential is low-rank. M4 is the non-circular test.
M3 — The gate estimated ~1,261 parameters from 158 targets.
At the ridge the published gate selected, the effective degrees of freedom Σ sᵢ²/(sᵢ²+λ) of the pooled-difference operator is 1,261 of 1,800 — eight estimated parameters per target. The pool is not rank-deficient (hard rank 1,488) but it is badly conditioned: participation ratio 83, condition number 3,752.
M4 — Rank 2 beats the free tensor, and beats the engine's own score, with 74 parameters.
Identical features, identical pool-softmax objective, identical folds; only the weight manifold differs. 5-fold CV averaged over 3 fold draws, on the 158 targets whose pool holds a near-native pose. CP fits are warm-started from the ALS decomposition of that fold's own free fit, so non-convexity is not what is being measured.
| parameterisation | params | ridge | CV top-1 | range |
|---|---|---|---|---|
| CP rank 1 | 37 | 0.001 | 64.8% | 95–109 |
| CP rank 2 | 74 | 0.01 | 69.0% | 106–113 |
| CP rank 3 | 111 | 0.01 | 65.0% | 101–106 |
| CP rank 4 | 148 | 0.001 | 65.2% | 103–103 |
| CP rank 6 | 222 | 0.01 | 55.9% | 87–90 |
| CP rank 8 | 296 | 0.001 | 58.2% | 88–97 |
| CP rank 16 | 592 | 0.01 | 54.9% | 85–89 |
| free tensor (the published gate) | 1800 | 1.0 | 59.3% | 92–95 |
The curve is unimodal and it decays back onto the free tensor: rank 2 is +9.7 points over the free tensor and +5.7 over the engine's own score, and by rank 6–16 the advantage is gone — 54.9–58.2%, at or below the 1,800-parameter fit. That shape is the signature the identifiability story predicts. It is not a regularisation-strength effect either: ridge on the CP factors bounds the tensor far more weakly than ridge on the tensor, so what is helping is the shape of the constraint — separability — not shrinkage. Sweeping the free tensor's ridge from 0.1 to 300 never exceeds 59.3%.
Leakage control. Permuting the positive index within each training target collapses both arms to chance — free tensor 22.5%, CP rank 2 21.8% — so the gap is signal, not pipeline.
M5 — replicated at 62× the data, and the optimal rank moves with it.
The same cache built from scratch/g0c-ranker-v4: 15,204 targets × 8
poses with symmetry-corrected labels, 9,766 rankable. The pooled features were
already in the corpus — pairs is the hat-basis expansion, columns
decoded from ranker_v2.py — so no PDBQT parsing and no re-derived typing rule.
Faithfulness R² = 0.9636.
| parameterisation | params | CV top-1 |
|---|---|---|
| CP rank 1 | 32 | 75.5% |
| CP rank 2 | 64 | 79.4% |
| CP rank 4 | 128 | 81.4% |
| CP rank 8 | 256 | 82.1% |
| CP rank 16 | 512 | 81.6% |
| CP rank 32 | 1024 | 81.8% |
| free tensor | 1188 | 79.9% |
The optimal rank grew 2 → 8 as the corpus grew 158 → 9,766, and the low-rank margin over the free tensor shrank from +9.7 to +2.2 points without vanishing. That is exactly what an identifiability story predicts and a chemistry story does not: the rank constraint is a variance reduction whose value falls as variance falls, and whose optimal strength tracks how much data there is to spend. So rank is a fitted hyperparameter, not a constant — "rank 2" is a fact about a corpus, not about combining rules.
One asymmetry worth flagging: the free tensor's optimum sits at the lowest ridge swept on g0c (0.1), so its arm may be slightly under-tuned, while every CP arm's optimum is interior.
The additive class is expressive enough to be perfect on this data (M1). The object it needs to represent occupies a few hundred parameters (M2). The gate spent 1,261 (M3). Constraining the manifold to its intrinsic shape recovers the loss (M4), and the effect replicates at 62× the data with the optimal rank tracking corpus size (M5). The additive-field programme was not defeated by additivity, and not simply by corpus size either; it was defeated by fitting a free tensor where physics says a combining rule belongs. The remedy is 64–256 parameters and is free at inference.
The two failure modes it was previously confused between are now separable. Additivity is not the constraint — M1 settles that. Corpus size is a constraint, but it is not the whole story: at 9,766 targets the free tensor is finally identifiable and still loses to a 256-parameter factorisation by 2.2 points. What the combining-rule prior buys is not merely variance reduction that more data would erase; some of it survives.
Vina's H-bond term is a radial ramp gated by two booleans. It has no angular dependence at all: a donor–acceptor pair at 2.8 Å scores identically whether the hydrogen points at the acceptor or 180° away. This is the most-cited deficiency of the empirical form, and it is usually described as incompatible with grid docking. It is not.
Receptor-side directionality costs zero channels.
The receptor's H-bond geometry is fixed. Multiplying each receptor atom's contribution by its
own angular factor while filling the grid changes what
Φ(x) contains and nothing else — same map count, same correlation, same
search, same runtime. It is a change to grid.rs's fill loop, not to the engine.
Ligand-side directionality — the ligand donor's own H direction — genuinely costs channels, but a bounded number. Expanding the angular factor g(n̂ᵢ·r̂ᵢⱼ) in Legendre polynomials and using P_l(n̂·r̂) = 4π/(2l+1) Σ_m Y_lm(n̂)* Y_lm(r̂) puts the receptor side into (l_max+1)² precomputed fields and leaves the ligand side as per-atom coefficients that are constants at fixed orientation. The truncation cost, measured:
| angular factor | l_max | channels | rel. L2 error |
|---|---|---|---|
| max(cos γ, 0)² | 3 | 16 | 3.0% |
| max(cos γ, 0)⁴ | 4 | 25 | 4.4% |
| max(cos γ, 0)⁴ | 6 | 49 | 0.44% |
| hard cutoff, γ < 30° | 8 | 81 | 38.5% |
Design rule: smooth angular factors only, never a hard angular cutoff.
A step function does not converge — 38.5% relative error at l_max = 8, and it is still 38% at 81 channels. That is Gibbs, and no channel budget fixes it. Every angular term must be C⁰ in the angle.
And the angle carries signal — measured, with no fitting at all.
154 DEV2 targets holding both a near-native pose and a ≥ 4 Å decoy. Deliberately training-free: fitting 360 directional channels on 158 targets would confound "no signal" with "not identifiable", which is the exact failure §3 diagnosed. AUC is the probability that a random near-native pose outscores a random decoy from the same target.
| statistic | per-target AUC | targets > 0.5 | pooled AUC |
|---|---|---|---|
| pairs at h-bond distance (Vina's rule) | 0.589 | 92/154 | 0.545 |
| the same pairs × max(cos γ,0)² | 0.662 | 99/154 | 0.576 |
Paired per target: 84 win / 62 lose / 8 tie, median Δ +0.025, exact sign test p = 0.082. The magnitude is meaningful (+0.073 median AUC); the consistency is borderline. Read it as worth building, not proven. Pooled AUC sits below per-target for both statistics — that is the ligand-size offset, and it is why per-target is the right view.
The blocker is upstream. parse.rs:129 "discards hydrogens from the
physics, but marks their heavy atom parents", so the donor H coordinates that set the direction are
parsed and thrown away. They are present in the data — the first SPINDR test receptor carries 54
HD atoms of 281 — so the direction is dropped, not missing. Retaining the polar-H direction on the parent atom is the prerequisite.
Where the receptor was prepared without polar hydrogens, hbond_repair.rs already
reconstructs the role from residue chemistry, and backbone N–H direction is fixed by C and CA;
hydroxyls are the genuinely ambiguous case and should fall back to isotropic.
The model below predicted a non-monotonic accuracy curve in the basin-measure floor. It was built, measured on 225 targets, and there is no such curve.
Best floor sits at the θ = 0 endpoint. Every binding floor is flat or negative, and the soft free energy — W1's own ranking rule — is worse than plain argmin.
| selection rule | top-1 | vs argmin | p |
|---|---|---|---|
| argmin E (what the engine does) | 19/225 (8.4%) | — | — |
| size ≥ 8 … 64 | 19/225 | +0 | 1.00 |
| size ≥ 128 | 16/225 | −3 | 0.375 |
| size ≥ 256 | 14/225 | −5 | 0.062 |
| size ≥ 1024 | 17/225 | −2 | 0.625 |
| argmin F (soft, W1's rule) | 16/225 (7.1%) | −3 | 0.375 |
| oracle over retained basins | 72/225 (32.0%) | — | — |
The headroom is real and the rule does not touch it. 8.4% against a 32.0% pool ceiling, and no measure threshold recovers any of it. That the soft free energy also loses is the first direct test of W1's central rule, and it does not pass.
Two limits on the refutation, stated because they bound it. size is the sublevel measure within one orientation's field, so it sees translational extent and is blind to rotational extent — while the model's p_k is over both. The rotational proxy was measured too (retained basins within 1 Å pose RMSD) and comes back uninformative rather than negative: median multiplicity is 1, so every floor above 3 binds no targets. And 19 hits is a small numerator — this excludes a large effect, not a small one.
Also worth correcting: I claimed this was checkable against archived data with no new docking.
It was not. src/landscape.rs is referenced only by features.rs and is
wired into no docking path, so no archived run carries basin measures. The gate had to be built.
The repo records an anomaly that deserves a mechanism rather than a shrug:
"an exact optimiser of a wrong objective finds the global optimum of wrongness … QuickVina2's sloppy stochastic search is accidentally protected from its own objective's worst decoys. Rustina is not."
Proposition. Finite-restart stochastic search is not approximate minimisation of E. It is exact minimisation of E subject to a constraint on basin measure.
Let steepest descent partition the pose space into basins B_k with minima E_k and start-measure p_k = μ(B_k), indexed so that E_1 < E_2 < …, and write q_k = Σ_{j<k} p_j for the measure of everything strictly better. The R restarts are i.i.d. draws over basins, so basin k is reported exactly when some draw lands in it and none lands in a better basin:
(the two terms are "no draw better than k" minus "no draw better than k and none in k"; writing it as a product over basins would wrongly assume independence across a multinomial). Expanding, P_k ≈ R·p_k·e^{−R q_k} in the small-measure regime: a basin is reported only if R·p_k ≳ 1, and is suppressed once R·q_k ≫ 1. So the search returns
with probability approaching 1. The restart budget is a trust region in measure, not in distance. ∎
This explains the anomaly exactly. Empirical false minima are knife-edge — one lucky contact, tiny basin. Native poses sit in broad, redundant basins. Monte Carlo's budget silently imposes p ≥ 1/R and throws the knife-edges away for free. Exhaustive argmin removes the constraint, and with it the protection. An exhaustive engine must re-impose the measure constraint explicitly — and it can do so better than MC, because it computes p_k exactly instead of sampling it, and can tune the threshold instead of inheriting it from a budget.
src/landscape.rs already computes basin volume, partition function and occupancy, so
the machinery exists. What it currently does with them — rank by basin free energy
F = E − kT ln Z — is a soft trade. The proposition says MC's
implicit rule is a hard floor. Those are different estimators, and separating them is the
experiment.
Prediction 1 — non-monotonicity in θ — was the kill criterion, and it failed. The remaining two (θ* ≈ 1/R_eff; losses to qvina2 enriched in small-p basins) are moot: with no interior θ* there is nothing to compare a restart budget against.
Why keep it. It is the only stated mechanism for an anomaly the repo has recorded twice, it made a prediction sharp enough to kill in an afternoon, and its death is informative — the protection qvina2 enjoys is not a basin-volume effect at translational resolution, so whatever explains the anomaly is still unidentified. The next candidate worth a gate is that MC's protection is conformational rather than positional: its restarts perturb torsions, so it never visits the sharp intramolecular minima an exact torsion search finds. That is consistent with §3.5's accuracy-neutral exact-torsion result, and this gate — running a rigid conformer — could not have seen it.
§3.7 refuted driver-cell branch and bound on measurement, and — unusually — measured the cause: a cell bounds the drivers, the closers swing by ‖J_c⁻¹J_d‖·radius, and that amplification saturates the π cap until the half-width is under π/16. So the cell does not localise atoms, and an eroded map over a 2.8 Å ball is near the map's global minimum. The stated requirement for a repair is exactly right: a bound that "acts on something the cell actually controls — the ring's own closed geometry".
Three candidates, in increasing order of ambition and decreasing order of certainty:
Make the cell an axis-aligned box B_i ⊆ R³ per ring atom. Then
Σ_i min_{x∈B_i} Φ(x) is admissible and tight to voxel resolution
— erosion.rs already computes it — and the amplification factor is gone by
construction, because atom motion is the box width. Feasibility ("does a closed ring fit in
these boxes?") is classical distance geometry: derive interval distance bounds from the boxes,
intersect with the rigid 1-2 and 1-3 distances, and run triangle-inequality bound smoothing
(Crippen–Havel, O(m³) per node). An inconsistency certifies emptiness.
Smoothing is incomplete, so prunes are valid but may be weak — the bound stays admissible either
way. This attacks the measured cause directly and is the one to build first.
§3.1's Levenberg–Marquardt projector works (100% success) but costs 531 ms per closure pair, needs 8-step continuation, and — §3.7 — only 38.7% of projections land back inside their own cell, so driver cells do not even partition the manifold. Analytic loop closure (Coutsias, Seok, Jacobson & Dill 2004) solves the 3-torsion closure problem in closed form as the roots of a degree-16 polynomial: every solution is exactly closed, all branches are enumerated, there is no corrector and therefore no cell-integrity defect, and the parameterisation (free torsions, branch index) is global. It also makes the manifold's singularities visible — they are the double roots — where the driver parameterisation only felt them as unbounded amplification.
Lift τ_k → (cos τ_k, sin τ_k) with c²+s²=1; closure becomes four polynomial equations and atom positions become multilinear. With a polynomial lower envelope of the eroded map over the ring's reachable ball, minimising the energy subject to closure is a polynomial optimisation problem, and the Lasserre/SOS hierarchy returns certified lower bounds that act on the closed geometry itself. This is the mathematically correct answer to §3.7's question. It is also an SDP whose size grows fast in the ring size, so treat it as the principled fallback, not the first build.
None of these is claimed to beat the covering-number wall. §3.4's extrapolation — ~2×10⁷ conformers at dimension 9 — stands, and it is a statement about enumeration that no bound repair contradicts. What (a)–(c) buy is a B&B whose failure, if it fails, will be for a different and more informative reason than the one already measured.
The pooled nonlinearity buys nothing at this corpus size.
An MLP head over 4, 8 and 16 pooled channels, warm-started from the linear fit and sharing its skip term, was fitted on the same folds. In-sample it is perfect — but so is the linear head (M1), so the comparison is uninformative there. In CV it tops out at exactly the linear number (92/158 = 58.2% at ridge 1.0), which is the head being regularised back onto its own skip connection, and at weaker ridge it is worse (34.8–37.3%).
Theorem 1 says the class is searchable; it does not say the class is learnable from 158 targets. Do not quote §1 as evidence that a nonlinear head helps. It is not, and this measurement says the opposite at this scale.
Everything in §1–§2 is now executable and covered by tests; §3–§5 all ran. The plan this document opened with has been executed rather than proposed, so what follows is status, not sequencing.
| item | state | evidence |
|---|---|---|
| Multi-channel correlation + pooled head | built | correlate_channels, fuse; exact against atom-major brute force
at every lattice point, and bit-identical to correlate at one
linear channel |
| CP-factorised potential | built | CpPotentialFile; loads through the existing from_json, and the
Python fitter's export reproduces Rust's score_direct to 2.2e-07 |
| Rank result, DEV2 | measured | rank 2 at 69.0% vs free tensor 59.3%, leakage control at chance |
| Rank result, 9,766 targets | measured | crossover: the free tensor wins at scale (§3) |
| Basin-measure floor | refuted | no interior optimum on 225 targets (§5) |
| H-bond directionality carries signal | measured | AUC 0.589 → 0.662, training-free (§4) |
| Exact torsion search under a monotone head | proved, not built | §2 — the A* heuristic reuses the existing DP's own messages |
| Landscape tensor / closed-loop training | not started | the only thing that makes a learned field safe as a generator |
What to do next, in order.
parse.rs; the change itself is one multiply in grid.rs, behind a flag,
with bit-identity when off.