Pose-Quantization Gate

Nothing downstream can run without a canonical SE(3) grid. Grep found no fibonacci or UnitQuaternion symbol in src/, so the rotation set is either inside examples/correlation_dock.rs (149 KB, the driver) or generated inline. Find it first — the gate must snap to the same rotations the production engine enumerates, or it measures nothing.

Then add src/se3_grid.rs:

pub struct Se3Grid {
    rotations: Vec<UnitQuaternion<f32>>,  // Super-Fibonacci, N configurable
    origin: Point3<f32>,
    spacing: f32,
    dim: (usize, usize, usize),
}

impl Se3Grid {
    /// Nearest rotation index by |q·q_i| (double-cover aware).
    pub fn snap_rotation(&self, q: &UnitQuaternion<f32>) -> usize;
    pub fn snap_translation(&self, t: &Point3<f32>) -> (usize, usize, usize);
    /// Full pose snap + the residual it discarded.
    pub fn snap(&self, m: &Isometry3<f32>) -> (Se3Index, PoseResidual);
}

Correctness

Unit test: snapping an exact grid pose returns zero residual. Snapping 10⁵ random poses gives a max angular residual within 15% of the analytic covering radius — if it exceeds that, the rotation set is not well-distributed and every downstream number is pessimistic for the wrong reason.

Double cover

Compare |q·qᵢ|, not q·qᵢ. Missing this silently doubles measured rotation error and is the single most likely bug in the whole gate.

The cheapest measurement and the one that can kill the design fastest. No grids, no scoring, no docking — exactly the philosophy torsion_reach.rs already establishes.

For each ligand at its native conformer:

1. Build the tree and let tf = tree.compute_transforms(&state). tf[g] is M_g — the API already exists.
2. Contract onto plan nodes with TorsionPlan::with_ring_policy(...).
3. Local coordinates: x_i^loc = tf[g].inverse() * coords[i] for i ∈ node_atom_ranges[g].
4. Displacement d_g = rms_i | snap(M_g)·x_i^loc − M_g·x_i^loc |.
5. Record d_g against depth(g), fragment radius of gyration, and atom count.

File

examples/pose_quantization_gate.rs

Invocation

--ligand L.pdbqt --n-rot 2048 --spacing 0.375 --depth 6

Reports

Per-depth median and p95 of d_g; whole-ligand RMS over all fragments; scatter of d_g against r_g to confirm the d ≈ r·ε model holds empirically.

Sweep

Spacing is the primary axis, not N_rot: sweep spacing ∈ {0.5, 0.375, 0.25, 0.2} at fixed N_rot = 2048 first, then N_rot only if the spacing sweep leaves a gap. Once fragment frames are centroid-centred the rotation lever arm is r_g ≈ 0.7–1.3 Å, so rotation error falls below the translation floor h/2 almost immediately and further rotations buy nothing.

Sampling

Never evaluate at State::new. The zero state makes every node transform the identity, so all fragments snap one single pose and the measurement never samples SO(3) — the first run's non-monotonicity in N_rot came from exactly this. Use ≥ 64 sampled states per target.

G1 measures geometry; this converts it into the currency that decides the search. Reuse PreparedMaps::from_grids and the existing correlation scoring so the numbers are in the engine's own units, not a proxy.

For each fragment: ΔΦ_g = Φ_g(snap(M_g)) − Φ_g(M_g), scoring g's atoms against the receptor maps at both poses. Total ΔE = Σ_g ΔΦ_g.

The number is meaningless in isolation, so measure the comparator in the same run: the decision gap, the energy spread between the best and second-best torsion tuple in the discrete set. Snapping is harmless when ΔE ≪ gap and fatal when it is comparable.

File

same binary as G1, behind --receptor R.pdbqt --maps

Reports

Distribution of ΔE (median, p95) in kcal/mol; distribution of the decision gap; the ratio ΔE / gap, which is the actual gate quantity.

Careful

Score with MapTransform::Raw for the headline number. The Curl fold applies at node resolution and would confound grid error with curl error — measure it separately, not by default.

The only end-to-end test, and the one that actually decides the programme. It needs a throwaway pose-DP — no FFT, no optimisation, correctness only — so that it can be compared against exhaustive ground truth.

Restrict to ligands with ≤ 6 free torsions at K ≤ 4 (≤ 4096 tuples), which makes brute force trivial.

Ground truth

Enumerate every τ ∈ Ω^n. Exact forward_kinematics, exact E_inter at true coordinates — no snapping anywhere. Keep the full ordering, not just the argmin.

Under test

Reference pose-DP with snapping at every transition, argmin torsion index stored per (child, parent grid pose), traceback to τ*.

Metrics

(a) exact-match rate of τ*; (b) rank of τ* in the true ordering; (c) energy regret E(τ*) − E(τ_opt); (d) heavy-atom RMSD between the two conformers.

File

examples/pose_dp_fidelity.rs

Do not gate on tuple identity. Symmetric substituents — a para-phenyl flipped 180°, for one — give a different tuple and a geometrically identical molecule, so exact-match and rank penalise the DP for decisions carrying no physical difference. Report them as diagnostics only. Geometric recovery is what refinement consumes.

And gate on the tail, not the median. A median hides a catastrophic minority, which is precisely the failure mode that matters in production.

Independent of the pose reformulation and worth running first, because it can invalidate the PoseBusters claim on its own. torsion_field.rs:105-119 records that 0 of 36 macrocycle closure pairs have both ends on a common root path, which is why the current field tears rings open and why RingPolicy::Frozen exists. Pose-space closure fixes the factorisation — but only if the discrete offset set Ω contains a conformer that actually closes the ring.

"Can any member of Ω^K close the ring?" is vacuous. Offset zero is always in the set and offsets are applied relative to the input torsion, so member zero is the input conformer — whose glue atoms coincide by construction. Any test that accepts on a best-over-trials basis reports 100% at every K and measures nothing.

The question RingPolicy actually poses is a different one: what fraction of Ω^K leaves the ring intact? The field minimises over the whole product space, so if intact conformers are a vanishing fraction of it, the minimum lands on a torn ring however many closed members exist.

1. Identify closure pairs via tree.ring_torsions and the Meeko glue atoms.
2. Enumerate (or systematically sample up to 20k of) Ω^K from the input conformer; count members satisfying closure. That fraction is the headline number.
3. Separately, measure reachability from perturbed starts — excluding the untouched input conformer, which closes trivially.
4. Sweep K ∈ {3, 6, 12, 24}.

File

examples/ring_closure_reach.rs

Monotonicity

Required. Ω(K′) ⊆ Ω(K) whenever K′ divides K, so results must be non-decreasing in K. Enforce it by carrying each pair's best solution forward as a seed for the next K. A decreasing pass rate is proof of search failure, never of representability failure — the first run's 62.5% → 12.5% drop came from an exhaustive/heuristic switch whose threshold depended on K.

Epistemics

The search is heuristic above the exhaustive cap, so a FAIL bounds representability from below and is never conclusive on its own. Only a PASS is.

Data

8 macrocyclic targets / 16 closure pairs in the SPINDR test split. The "36 pairs" in the RingPolicy docstring spans both benchmark sets.

This is a sharper statement than "the ring claim is dead." Uniform offsets are not unable to represent closure — they contain closed members. They are unable to make closure anything but a measure-zero event inside the space the field searches. RingPolicy::Frozen is therefore correct as a stopgap, and the finding motivates the pose-space closure constraint rather than killing it: constraining the DP to the closed sub-manifold is exactly the way to stop searching a space that is 99.6%+ broken molecules.

The table above says naive materialisation costs ~20 GB. This gate measures whether the reachable-set restriction rescues it. Fragment g's frame origin is confined to a ball of radius L_g — the chain length from root to g — around the root translation, so A_g only needs support on that ball, not the whole box.

Measure L_g across the benchmark ligands and compute true support sizes. A 5 Å ball at 0.375 Å spacing is ~2,500 lattice points against 300k for the full box — a 120× reduction, if it holds.

Reports

Distribution of L_g by depth; resulting per-fragment and total footprint at each N_rot; the crossover N_rot where total exceeds 8 GB.

Watch

The restriction is relative to the root translation, so a relative-frame formulation makes A_g depend on the root pose and the DP must rerun per root pose. Quantify that cost here — it is the difference between materialised messages and root-outward branch-and-bound.