Matcha: Multi-Stage Riemannian Flow Matching for Accurate and Physically Valid Molecular Docking

## Abstract

Abstract Accurate prediction of protein-ligand binding poses is crucial for structure-based drug design, yet existing methods struggle to balance speed, accuracy, and physical plausibility.
We introduce Matcha , a novel molecular docking pipeline that combines multi-stage flow matching with learned scoring and physical validity filtering.
Our approach consists of three sequential stages applied consecutively to progressively refine docking predictions,
each implemented as a flow matching model operating on appropriate geometric spaces ( ℝ 3 \mathbb{R}^{3} , SO ​ ( 3 ) \mathrm{SO}(3) , and SO ​ ( 2 ) \mathrm{SO}(2) ).
We enhance the prediction quality through a dedicated scoring model and apply unsupervised physical validity filters to eliminate unrealistic poses.
Compared to various approaches, Matcha demonstrates superior performance on Astex and PDBbind test sets in terms of docking success rate and physical plausibility.
Moreover, our method works approximately 25 × 25\times faster than modern large-scale co-folding models.
The model weights and inference code to reproduce our results are available at https://github.com/LigandPro/Matcha .

## 1 Introduction

Molecular docking aims to predict the binding pose of a small molecule (ligand) within the active site of a target protein.
It plays a key role in computer-aided drug discovery, particularly in virtual screening, the computational search for promising drug candidates within large-scale compound libraries.
Given the vast size of these libraries, practical docking methods must balance accuracy with computational efficiency.
Additionally, predicted poses are expected to be physically plausible (Buttenschoen et al., 2024).
Another challenge is the diversity of existing docking benchmarks, which differ substantially in target and ligand selection, making it difficult to design methods that generalize well across all datasets.

Classical docking approaches (Friesner et al., 2004; Trott and Olson, 2010; Koes et al., 2013; Forli et al., 2016; Sulimov et al., 2020) have traditionally relied on hand-crafted scoring functions combined with heuristic search algorithms.
However, recent benchmarks (Morehead et al., 2025) demonstrate that such methods are outperformed by data-driven approaches.

Modern data-driven blind docking methods (Abramson et al., 2024; Boitreaud et al., 2024; Wohlwend et al., 2024), starting from the seminal DiffDock (Corso et al., 2022), typically formulate molecular docking as a generative modeling problem, where a neural network — often a diffusion model — learns to sample ligand poses from a probabilistic distribution.

Our proposed method, Matcha, follows this generative paradigm but is based on flow MATCHing (Lipman et al., 2022) rather than diffusion.
Following DiffDock, we represent ligand flexibility in a joint space of translations, global rotations, and internal torsions.
This corresponds to a semi-flexible ligand: the conformation is fixed except for rotations around rotatable bonds.
In contrast to Riemannian diffusion-based methods, Riemannian flow matching (Chen and Lipman, 2023) provides tractable losses in these spaces and simplifies training.
Moreover, our approach naturally bypasses the need for semi-flexible conformational alignment, which is a challenging optimization problem.
To the best of our knowledge, it is the first docking pipeline that is built upon flow matching on non-Euclidean manifolds.

Architecturally, Matcha combines the structure of a Diffusion Transformer (DiT; Peebles and Xie 2023) with a spatial encoder inspired by UniMol (Zhou et al., 2023).
Our pipeline consists of three neural networks trained at different noise levels.
For instance, the first model is optimized to predict the 3D translational displacement of the ligand center relative to the binding site.
By default, Matcha is trained for blind docking, but the pocket-informed setting can be managed by omitting the coarse model and providing the correct binding site location.
Also, we train a separate scoring model to select the best pose among all generated candidates.

Our main contributions are as follows:

- •
We introduce Matcha, a neural pipeline for molecular docking that combines Riemannian flow matching with a DiT-inspired architecture.
The pipeline employs three neural networks applied consecutively to refine docking predictions progressively.
- •
We perform an extensive empirical evaluation of Matcha against state-of-the-art methods, comparing binding quality, computational efficiency, and physical plausibility across the PDBBind, DockGen, Astex, and PoseBusters V2 benchmarks.
- •
Matcha achieves inference approximately $25\times$ faster than AlphaFold 3, Chai-1, and Boltz-2, while having state-of-the-art docking performance on the Astex test set: 66% with $\mathrm{RMSD}\leq$2\text{\,}\mathrm{\SIUnitSymbolAngstrom}$$ & PB-valid (Buttenschoen et al., 2024) and competitive results on other benchmarks.

## 2 Method

Figure: Figure 1: Matcha consists of three flow matching models that generate a set of ligand poses. After unsupervised physical validity filtration, all poses are scored with a separate model, and the prediction is the pose with the best score. We highlight rotatable bonds and their periods in the ligand on this figure.
Refer to caption: x1.png

### 2.1 Docking loss function

Matcha tackles the molecular docking problem by modeling a protein as a rigid body while parameterizing the ligand’s degrees of freedom in a manner similar to DiffDock. Specifically, we operate in the following spaces:

- •
translation (tr): a 3D continuous vector representing the position of the ligand’s center relative to the protein,
- •
rotation (rot): an $\mathrm{SO}(3)$ transformation matrix representing the orientation of ligand,
- •
torsion angles (tor): a set of angles in $\mathrm{SO}(2)$, one for each rotatable bond in the ligand.

For rotatable bonds, we define the torsional period $p$ as the smallest positive angle such that a rotation by $p$ about that bond yields an indistinguishable configuration (up to symmetry).
Accordingly, torsion angles are taken modulo $p$, i.e., for any $\theta$ we use its wrapped representative $\theta\bmod p$ that is in $\left(-p/2,\,p/2\right]$.

Our model predicts velocities ${\bm{v}}_{\mathrm{tr}}$, ${\bm{v}}_{\mathrm{rot}}$, and ${\bm{v}}_{\mathrm{tor}}$ in the tangent spaces $\mathbb{R}^{3}$, $\mathfrak{so}(3)$, and $\mathfrak{so}(2)^{m}$, with $m$ denoting the number of rotatable bonds.
Elements of $\mathfrak{so}(n)$ can be thought of as $n\times n$ real skew-symmetric matrices (Warner, 1983), we represent them as $n(n-1)/2$-dimensional vectors.

We compute separate flow matching losses (Chen and Lipman, 2023) for each component and optimize their weighted sum.
Generally, to train a flow matching model ${\bm{v}}_{\bm{\theta}}$ given data points ${\bm{x}}_{1}$ on a Riemannian manifold $\mathcal{M}$ drawn from $p_{\mathrm{data}}$, we should define a noise distribution $p_{0}$.
Then we choose an interpolation on $\mathcal{M}$, select an appropriate norm, and compute the time derivative of the interpolation to obtain the conditional velocity.
The conditional flow matching loss takes the form:

$$ $\mathcal{L}_{\mathrm{CFM}}=\mathbb{E}_{{\bm{x}}_{0}\sim p_{0},{\bm{x}}_{1}\sim p_{\mathrm{data}},t\sim\mathrm{U}[0,1]}\|{\bm{v}}_{\bm{\theta}}({\bm{x}}_{t},t)-\dot{{\bm{x}}_{t}}\|,\ \text{where}\ {\bm{x}}_{t}=\mathrm{interpolate}({\bm{x}}_{0},{\bm{x}}_{1};t).$ (1) $$

For translations, we use a standard linear interpolation and normally distributed noise.
For both angular components, we adopt spherical linear interpolation (SLERP; Shoemake 1985).
In $\mathrm{SO}(3)$, the time derivative of SLERP is computed by transforming to quaternion representations and applying automatic differentiation with custom backward functions.
Additional derivation details are provided in Appendix [A](https://arxiv.org/html/2510.14586v2#A1).

### 2.2 Architecture

Figure: Figure 2: The architecture of the velocity model of Matcha (stages 1, 2, 3).
Refer to caption: x2.png

Matcha consists of two primary components (Figure [1](https://arxiv.org/html/2510.14586v2#S2.F1)): the docking pipeline and the scoring model.
These components are implemented through a transformer-based architecture and have a similar design (Figure [2](https://arxiv.org/html/2510.14586v2#S2.F2)).

#### 2.2.1 Velocity model

##### Input tokens

The input sequence consists of ligand atom tokens, protein amino acid residue tokens, and two CLS-like tokens for aggregating translation ($\mathrm{CLS}_{\mathrm{tr}}$) and global rotation ($\mathrm{CLS}_{\mathrm{rot}}$) information.
Each token is assigned a 3D coordinate: atom positions for ligand atoms, $C_{\alpha}$ positions for residues, and the ligand centroid for both CLS tokens.
Protein representations are initialized from ESM-2-35M (Lin et al., 2022) embeddings; we use the 35M model instead of the 650M variant to reduce the risk of overfitting.
Initial ligand atom embeddings are a sum of simple embeddings of scalar and categorical atom features from the RDKit package (Landrum, 2024).

Time $t\!\in\![0,1]$ is embedded by an MLP over sinusoidal features and conditions all transformer blocks in a DiT-like manner.
Positions $(x,y,z)$ are encoded using a simple MLP and added to both embeddings of ligand atoms and protein residues in a manner of positional encoding in transformers.

##### Distance-aware attention bias

We adopt the approach from UniMol and AlphaFold 3, where spatial features are used as extra biases in self-attention.
Given 3D coordinates $x=\{x_{i}\}_{i=1}^{N},\;x_{i}\in\mathbb{R}^{3}$, we form a per-head attention bias by combining a radial (distance-based) and a directional (vector-based) term. For a pair $(i,j)$ with edge type $t_{ij}\in\{1,\dots,T\}$, define the displacement $\Delta_{ij}=x_{i}-x_{j}$ and a stabilized inverse distance

$$ $s_{ij}\;=\;\frac{1}{\|\Delta_{ij}\|_{2}^{2}+1}\,.$ (2) $$

An edge-type–specific affine transform produces $\tilde{s}_{ij}=\alpha_{t_{ij}}\,s_{ij}+\beta_{t_{ij}}$. We then embed $\tilde{s}_{ij}$ with a $K$-kernel Gaussian RBF:

$$ $\phi^{(k)}_{ij}\;=\;\mathcal{N}\!\big(\tilde{s}_{ij}\,;\,\mu_{k},\sigma_{k}^{2}\big),\qquad k=1,\dots,K,$ (3) $$

followed by a small MLP projection $g:\mathbb{R}^{K}\!\to\!\mathbb{R}^{H}$ to obtain a per-head radial bias $o_{ij}=g(\phi_{ij})\in\mathbb{R}^{H}$. In parallel, a directional projection $h:\mathbb{R}^{3}\!\to\!\mathbb{R}^{H}$ maps the displacement to $v_{ij}=h(\Delta_{ij})$.
The per-pair bias is
$b_{ij}=g(\phi_{ij})+h(\Delta_{ij})\in\mathbb{R}^{H}.$
Stacking over all pairs yields a tensor in $\mathbb{R}^{N\times N\times H}$; we then move the head dimension to the front to obtain
$B_{hij}=[b_{ij}]_{h}\in\mathbb{R}^{H\times N\times N},$
which we add to the attention logits.

##### Velocity prediction heads

After the transformer backbone, we employ lightweight modules to predict the velocity fields.
We do not force rotational or translational symmetries via the architecture; instead, we rely on data augmentations during training to promote invariances and equivariances.

The translation head consumes the dedicated $\mathrm{CLS}_{\mathrm{tr}}$ token and outputs a 3D velocity vector $v_{\mathrm{tr}}\in\mathbb{R}^{3}$.
The rotation head consumes the $\mathrm{CLS}_{\mathrm{rot}}$ token and outputs a 3-vector representation of $\mathfrak{so}(3)$.
For torsions, we construct a token for each rotatable bond by averaging the embeddings of ligand atoms influenced by the rotation of that bond and combining this with an encoding of basic features of the bond level.
The resulting per-bond sequence is passed through a lightweight transformer decoder, and a final single-layer MLP projects each token to a scalar torsional velocity $v_{\mathrm{tor}}$.

##### Coarse-to-fine structure

Our pipeline stacks three models of identical architecture but independent weights.
The first model is used solely for translation, where samples are drawn from a zero-mean Gaussian distribution with a large variance, while angular components are sampled uniformly.
The second model refines translation using a Gaussian centered at the ground truth with moderate variance, still keeping angular components uniform.
Finally, the third model sharpens both translation and angular degrees of freedom, sampling them from Gaussians with small variance around the ground truth.
The models are trained independently.
Full details are provided in Algorithm [1](https://arxiv.org/html/2510.14586v2#alg1).

The system can operate in two distinct scenarios: blind docking and pocket-aware docking.
Blind docking means predicting ligand poses without prior knowledge of the binding site location, while in the pocket-aware scenario, the information about the known binding site is used to guide pose prediction.
This flexibility is achieved because of the multiscale nature of Matcha.

##### Augmentations

During training, we apply multiple augmentation techniques to avoid overfitting and improve model generalization.
Firstly, we randomly rotate the whole complex to get new $(x,y,z)$ coordinates.
Secondly, we add random Gaussian noise with zero mean and standard deviation 0.25 to the protein and ligand positions.
Finally, we randomly mask $15\%$ of protein residues and ligand atoms.
This strategy also leads to masking of some rotatable bonds.

##### Inference

We run a fixed-length explicit Riemannian Euler solver (10 steps) over $(\mathrm{tr},\mathrm{rot},\mathrm{tor})$ using the predicted velocities, applying three models sequentially.

- Stage 1
From a random initialization, we integrate all degrees of freedom (translation, rotation, torsions), but retain only the predicted translation; the angular components are discarded and reinitialized uniformly.
- Stage 2
Starting from this state (predicted translation and uniformly distributed angles), we perform the same rollout and pass the full output $(\mathrm{tr},\mathrm{rot},\mathrm{tor})$ forward.
- Stage 3
We execute the final rollout to produce the refined pose.

Figure: Algorithm 1 General scheme of Matcha docking training

#### 2.2.2 Pose selection

##### Scoring model

We train a separate pose–scoring network to evaluate and rank candidate docking poses.
It shares the backbone with our docking model but removes time conditioning and all flow matching components.
Instead, a dedicated scalar scoring head is optimized with an RMSD-based pairwise ranking objective for comparative pose assessment.
For training, each batch is composed of multiple noisy poses of the same protein–ligand complex, and the model learns to order the resulting pairs of poses.

##### Pose filtration

We reimplement, speed up, and apply a minimal set of PoseBusters geometric and physicochemical validity filters before scoring.
Specifically, we retain candidate complexes that achieve the highest filter scores across key validity criteria: (i) *Minimum distance to protein*, preventing ligand–receptor atomic collision; (ii) *Protein–ligand maximum distance*, excluding poses with excessive protein–ligand separation that are unlikely to form specific interactions; (iii) *Volume overlap with protein*, rejecting any nonzero volumetric overlap with the receptor; and (iv) *Internal steric clash*, removing ligand conformers with intramolecular clashes.
Filtration is strictly unsupervised—i.e., it does not rely on knowledge of the native pose – and is therefore readily applicable at inference.
In practice, for each complex we retain the poses that pass the highest number of validity criteria and then select a single pose using our learned scoring model.

## 3 Experimental setup

### 3.1 Datasets

Matcha is trained on two major protein-ligand complex datasets: PDBBind (Liu et al., 2017) and Binding MOAD (Hu et al., 2005).
During training, we keep only protein chains close to the ligand (less than $4.5$ Å).
We use complexes that have proteins with less than 2000 residues and ligands with $6-150$ heavy atoms.
At training time, we concatenate the Binding MOAD dataset to the PDBBind training set without removing redundant complexes, thereby giving additional weight to higher-quality complexes that passed both datasets’ filtering processes.

For the Binding MOAD dataset, we implement protein-level sampling to address the inherent class imbalance where multiple ligands are bound to the same protein structure.
During every training epoch, we sample each unique protein exactly once.
For each selected protein, we randomly choose one ligand from all ligands bound to that receptor.

The docking quality is evaluated on four test datasets.
Astex Diverse set (Hartshorn et al., 2007) and PoseBusters V2 Benchmark set (Buttenschoen et al., 2024) are commonly used in the field and contain 85 and 308 complexes, respectively.
DockGen (Corso et al., 2024) is a set of 330 hard complexes with binding sites different from the training set.
Finally, we use the PDBBind test set obtained using time-splitting of dataset complexes and has 363 complexes (Corso et al., 2022).

### 3.2 Training details

All models are trained with the AdamW optimizer (Loshchilov and Hutter, 2017) using a learning rate of $5\times 10^{-5}$.
The docking models employ a batch size of 24 and are trained on a single NVIDIA H100 GPU (80GB). Stage 1 training runs for 1.9M steps ($\approx 11$ days), stage 2 for 3.3M steps ($\approx 19$ days), and stage 3 for 1.4M steps ($\approx 8$ days), totaling 38 GPU-days.
The scoring model is trained separately with batch size 12 on an NVIDIA V100 GPU (16GB) for 700k steps ($\approx 26$ hours).

All Matcha models use 6 Complex DiT layers with hidden dimension 192. This corresponds to $\sim$29M parameters for the docking models and $\sim$6M parameters for the scoring model. For docking, we optimize a weighted objective with loss coefficients $w_{\text{tr}}=1$, $w_{\text{rot}}=1$, and $w_{\text{tor}}=3$.

### 3.3 Docking Quality Metrics

To comprehensively evaluate the performance of Matcha, we use symmetry-corrected Root Mean Square Deviation (RMSD) that accounts for molecular symmetry and report success rates at 2 Å threshold ($\mathrm{RMSD}\leq$2\text{\,}\mathrm{\SIUnitSymbolAngstrom}$$).
We also run PoseBusters tests (Buttenschoen et al., 2024) to assess physical plausibility of predicted poses, resulting in the combined metric $\mathrm{RMSD}\leq$2\text{\,}\mathrm{\SIUnitSymbolAngstrom}$$ & PB-valid.
Exact PoseBusters tests are listed in Appendix [F](https://arxiv.org/html/2510.14586v2#A6).
For models that predict whole complex structures, we follow Abramson et al. (2024) and use pocket-aligned symmetric RMSD by aligning the reference protein pocket to the predicted structure.
If a model crashes on a complex, we assign an RMSD of $+\infty$.
The details are reported in Section [4.5](https://arxiv.org/html/2510.14586v2#S4.SS5) and Appendix [D.1](https://arxiv.org/html/2510.14586v2#A4.SS1).

### 3.4 How we run baselines

##### Baseline model parameters

For AlphaFold 3 (Abramson et al., 2024), Boltz-2 (Passaro et al., 2025) and Chai-1 (Boitreaud et al., 2024), we use the prediction with the highest confidence score among five model seeds with five samples per seed and 10 recycling steps.
We used multiple sequence alignments computed with JackHMMER (HMMER3) (Eddy, 2011).
When modeling receptor structures, we preserve all chains and remove exact duplicate chains only.
NeuralPlexer (Qiao et al., 2024b), DiffDock (Corso et al., 2022) and Uni-Mol (Alcaide et al., 2024) are run with their default inference parameters.
We run FlowDock (Morehead and Cheng, 2025) using true holo protein structures as receptor templates.
For all methods, we take the top-scored sample among generated.
We detail the parameters that were used to run classical docking models (AutoDock Vina (v1.2.5) (Trott and Olson, 2010), SMINA (v2020.12.10; fork of Vina 1.1.2) (Koes et al., 2013), and GNINA (v1.0.3) (McNutt et al., 2021)) in Appendix [B](https://arxiv.org/html/2510.14586v2#A2).

##### Pocket Detection for Classical Docking Methods

Classical docking methods and Uni-Mol face fundamental challenges in blind docking due to their reliance on pocket identification algorithms.
This dependence introduces additional error when binding sites are unknown, representing a key limitation compared to end-to-end methods.
We evaluate these methods using P2Rank (Krivák and Hoksza, 2018), Fpocket (Le Guilloux et al., 2009), and whole protein approaches.
Among these, P2Rank has shown the best performance and is used as the primary pocket detection method for our main results.
The complete results are provided in Appendix [C.1.2](https://arxiv.org/html/2510.14586v2#A3.SS1.SSS2).

##### Matcha inference parameters

We run Matcha in two inference regimes: in blind docking setup using all protein chains and in the pocket-aware scenario with the correct binding site provided.
The first model in the pipeline generates 40 samples, which are then passed to the refinement stages.
Then, the plausibility filtering is applied, reducing the number of candidate poses.
We use the top-scored pose among the rest of the candidates.

## 4 Results and Discussion

### 4.1 Comprehensive Evaluation on Diverse Benchmarks

We evaluate Matcha against established baselines: classical docking (SMINA, VINA, GNINA), deep learning-based (DL-based) methods (DiffDock, Uni-Mol, NeuralPlexer and FlowDock) as well as co-folding models (AlphaFold 3, Chai-1, Boltz-2).
The results for DockGen dataset as well as all extended results are reported in Appendix [C.1](https://arxiv.org/html/2510.14586v2#A3.SS1).
Additionally, we evaluate the considered models in the pocket-aware scenario with the corrected binding site location provided (see Appendix [C.2](https://arxiv.org/html/2510.14586v2#A3.SS2)).

Figure: Figure 3: Blind ligand docking success rates on Astex Diverse Set ($n=85$).
Refer to caption: x3.png

Figure: Figure 4: Blind ligand docking success rates on PDBBind test set ($n=363$).
Refer to caption: x4.png

Figure: Figure 5: Blind ligand docking success rates on PoseBusters V2 dataset ($n=308$).
Refer to caption: x5.png

On the Astex dataset, Matcha demonstrates superior performance across all metrics, achieving the highest success rates for both $\mathrm{RMSD}\leq$2\text{\,}\mathrm{\SIUnitSymbolAngstrom}$$ (68.2%) and the harder $\mathrm{RMSD}\leq$2\text{\,}\mathrm{\SIUnitSymbolAngstrom}$$ & PB-valid (65.9%), outperforming the next-best method (AlphaFold 3) by 10.6 percentage points on physically valid structures.
The substantial improvement in the number of physically valid structures highlights the effectiveness of our flow matching approach in generating chemically plausible poses while maintaining high geometric accuracy.

On the PDBBind test set, Matcha demonstrates superior performance across all metrics compared to DL-based docking methods.
While co-folding methods achieve slightly higher $\mathrm{RMSD}\leq$2\text{\,}\mathrm{\SIUnitSymbolAngstrom}$$ success rates, Matcha shows the highest success rate of 43.8% for $\mathrm{RMSD}\leq$2\text{\,}\mathrm{\SIUnitSymbolAngstrom}$$ & PB-valid, surpassing even AlphaFold 3 (39.9%).
This demonstrates that Matcha produces the most physically plausible and chemically valid structures, making it particularly valuable for practical drug discovery applications.

The PoseBusters V2 dataset presents the most challenging evaluation scenario, where Matcha’s performance shows a relative decrease compared to co-folding methods due to a higher proportion of protein targets with binding pockets structurally dissimilar to the training data (Morehead et al., 2025).
Co-folding methods, trained on significantly larger and more diverse protein structure datasets, demonstrate better generalization to these out-of-distribution pocket geometries.
Nevertheless, Matcha maintains superior performance compared to other DL-based methods (DiffDock, NeuralPlexer, FlowDock), confirming the effectiveness of our approach within the shared training distribution.
This evaluation highlights the fundamental limitation of such models in generalizing beyond training data distributions.

### 4.2 Computational efficiency of Matcha

##### Inference Speed Analysis

We measure the average inference time for all considered blind docking methods one NVIDIA A100 40Gb GPU (see Figure [7](https://arxiv.org/html/2510.14586v2#S4.F7)).
Time is measured only for model inference avoiding model loading.
The exact timing results (in seconds) are detailed in Appendix [E](https://arxiv.org/html/2510.14586v2#A5).
Matcha demonstrates the best speed-accuracy balance in terms of fraction of PoseBusters-valid predictions with $\mathrm{RMSD}\leq$2\text{\,}\mathrm{\SIUnitSymbolAngstrom}$$, which is important in practical applications.
Matcha achieves substantially higher docking success rates compared to fast methods (DiffDock, NeuralPlexer, FlowDock), having even faster inference time.
Also, Matcha shows a significant speed advantage over high-accuracy co-folding methods, achieving comparable docking quality.

Figure: Figure 6: The dependence between the average docking inference time and percentage of PoseBusters-valid predictions for Astex dataset.
Refer to caption: x6.png

##### Training speed

Matcha required significantly less computational resources for training compared to competing methods: 38 GPU-days on a single H100 versus 120 GPU-days for DiffDock (4× RTX A6000) and 3,840 GPU-days for Chai-1 (128× A100).
This highlights Matcha’s efficiency in both training and inference compared to DL-based models and co-folding models.

### 4.3 Analysis of the required number of samples

Figure [7](https://arxiv.org/html/2510.14586v2#S4.F7) shows how the number of generated poses affects the quality of the best selected pose, comparing scoring-only regime, scoring with filtration (default), and oracle performance (representing the theoretical upper bound).
Using scoring model increases $\mathrm{RMSD}\leq$2\text{\,}\mathrm{\SIUnitSymbolAngstrom}$$ & PB valid from 0.22 to 0.27, while adding physically-aware post-filtration improves results to 0.44, demonstrating the critical importance of incorporating molecular validity constraints alongside learned scoring functions.
Performance plateaus at around 40 samples, marking the optimal computational cost-quality trade-off.
The gap between filtered scoring and oracle performance indicates remaining opportunities for improvement in pose selection, while the convergence behavior suggests that the current sampling strategy effectively explores the relevant conformational space within the first 40 generated poses.

### 4.4 Physical Validity Assessment

A critical advantage of Matcha lies in its ability to generate physically plausible molecular poses.
For instance, on the PDBBind test set, Matcha has 85.9% of physically-valid structures among those with $\mathrm{RMSD}\leq$2\text{\,}\mathrm{\SIUnitSymbolAngstrom}$$.
To compare, AlphaFold 3 has 68.9%, DiffDock – 50.7%.
This consistent superiority in generating chemically valid poses across different datasets demonstrates that Matcha’s flow matching approach effectively preserves molecular constraints through two key mechanisms: (1) ligand parametrization using only torsional angles, which maintains internal molecular geometry, and (2) fast and effective post-filtration to eliminate unrealistic complex poses.
The high fraction of physically plausible structures, combined with fast inference, makes Matcha particularly suitable for practical drug discovery applications where chemical validity and screening efficiency are as important as geometric accuracy.

### 4.5 Impact of Alignment Strategy on Reported Metrics

Pocket alignment refers to the procedure for superimposing predicted and reference protein–ligand complexes prior to RMSD evaluation, which is necessary for models that modify protein structure during prediction.
Different strategies lead to systematically different results.
One common option is the pocket-based alignment, where the predicted pocket is aligned to the reference one.
This can yield lower RMSD values even if the ligand is placed in a non-native binding site, effectively inflating success rates for both structure prediction and rigid docking methods.
In contrast, we follow the base alignment strategy, in which the reference pocket is aligned to the full predicted protein, ensuring that incorrect pocket assignments are penalized.
This methodological difference explains why our reported metrics may differ from those in other studies, even when using the same datasets.
Appendix [D](https://arxiv.org/html/2510.14586v2#A4) provides a detailed comparison, showing that pocket-based alignment consistently increases success rates by 10–20% across methods, while leaving their relative ordering unchanged.

## 5 Related Work

Prior work on molecular docking can be organized along several orthogonal axes.
One natural division is between classical heuristic-based approaches and modern deep learning methods.
Within these, methods can be further distinguished by whether they treat docking as rigid-body alignment or as a co-folding process, and by whether they rely on discriminative or generative modeling of the complex.

Co-folding approaches represent some of the most computationally demanding directions in molecular docking, as they attempt to jointly predict the conformations of both proteins and ligands.
Recent examples include AlphaFold 3 (Abramson et al., 2024), Chai-1 (Boitreaud et al., 2024), and Boltz-1/2 (Wohlwend et al., 2024; Passaro et al., 2025), NeuralPLexer family (Qiao et al. 2024b, Qiao et al. 2024a),
Interformer (Lai et al., 2024), DynamicBind (Lu et al., 2024), LaBind (Zhang et al., 2025b),
PhysDock (Zhang et al., 2025a).
These models are generally diffusion generative models in the Euclidean space.
Since co-folding methods model protein positions, they typically require large-scale training and long inference time.

In contrast, rigid docking methods assume a fixed protein conformation and focus on placing a flexible ligand into binding site.
This setting is computationally simpler than co-folding, yet it remains challenging due to the high dimensionality of ligand torsions and the rugged energy landscape of protein pockets.
Classical docking approaches, such as AutoDock Vina (Trott and Olson, 2010) and SMINA (Koes et al., 2013), rely on heuristic search combined with hand-crafted scoring functions.
Recent deep learning methods reformulate rigid docking either as a regression problem or as generative modeling.
Regression-based models, including EquiBind (Stärk et al., 2022), TankBind (Lu et al., 2022), E3Bind (Zhang et al., 2022), and FABind (Pei et al., 2023),
Uni-Mol (Alcaide et al., 2024), predict a single pose in one shot, often followed by torsional refinement of the ligand.
Generative methods, such as DiffDock (Corso et al., 2022) and FlowDock (Morehead and Cheng, 2025), instead learn distributions over poses and can sample diverse ligand conformations conditioned on the rigid receptor.

## 6 Conclusion

We introduced Matcha, a multi-stage Riemannian flow matching framework for molecular docking that combines geometric generative modeling, scoring, and physical validity filtering.
Matcha achieves a high physically valid docking accuracy while being substantially faster than many other models, making it suitable for large-scale applications.
A key limitation is reduced generalization to unseen protein pockets, pointing to future work on receptor flexibility and broader protein coverage.
Overall, Matcha strikes a practical balance between accuracy, efficiency, and physical realism for structure-based drug discovery.

## References

- Abramson et al. (2024)
Josh Abramson, Jonas Adler, Jack Dunger, Richard Evans, Tim Green, Alexander Pritzel, Olaf Ronneberger, Lindsay Willmore, Andrew J Ballard, Joshua Bambrick, et al.
Accurate structure prediction of biomolecular interactions with AlphaFold 3.
*Nature*, 630(8016):493–500, 2024.
- Alcaide et al. (2024)
Eric Alcaide, Zhifeng Gao, Guolin Ke, Yaqi Li, Linfeng Zhang, Hang Zheng, and Gengmo Zhou.
Uni-Mol docking V2: Towards realistic and accurate binding pose prediction.
*arXiv preprint arXiv:2405.11769*, 2024.
- Boitreaud et al. (2024)
Jacques Boitreaud, Jack Dent, Matthew McPartlon, Joshua Meier, Vinicius Reis, Alex Rogozhonikov, and Kevin Wu.
Chai-1: Decoding the molecular interactions of life.
*BioRxiv*, pages 2024–10, 2024.
- Brégier (2021)
Romain Brégier.
Deep regression on manifolds: a 3D rotation case study.
In *2021 International Conference on 3D Vision (3DV)*, pages 166–174. IEEE, 2021.
- Buttenschoen et al. (2024)
Martin Buttenschoen, Garrett M Morris, and Charlotte M Deane.
Posebusters: AI-based docking methods fail to generate physically valid poses or generalise to novel sequences.
*Chemical Science*, 15(9):3130–3139, 2024.
- Chen and Lipman (2023)
Ricky TQ Chen and Yaron Lipman.
Flow matching on general geometries.
*arXiv preprint arXiv:2302.03660*, 2023.
- Chen et al. (2010)
Vincent B Chen, W Bryan Arendall, Jeffrey J Headd, Daniel A Keedy, Robert M Immormino, Gary J Kapral, Laura W Murray, Jane S Richardson, and David C Richardson.
Molprobity: all-atom structure validation for macromolecular crystallography.
*Biological crystallography*, 66(1):12–21, 2010.
- Corso et al. (2022)
Gabriele Corso, Hannes Stärk, Bowen Jing, Regina Barzilay, and Tommi Jaakkola.
DiffDock: Diffusion Steps, Twists, and Turns for Molecular Docking.
*arXiv preprint arXiv:2210.01776*, 2022.
- Corso et al. (2024)
Gabriele Corso, Arthur Deng, Benjamin Fry, Nicholas Polizzi, Regina Barzilay, and Tommi Jaakkola.
Deep confident steps to new pockets: Strategies for docking generalization.
*ArXiv*, pages arXiv–2402, 2024.
- DeLano et al. (2002)
Warren L DeLano et al.
Pymol: An open-source molecular graphics tool.
*CCP4 Newsl. protein crystallogr*, 40(1):82–92, 2002.
- Eddy (2011)
Sean R Eddy.
Accelerated profile HMM searches.
*PLoS computational biology*, 7(10):e1002195, 2011.
- Forli et al. (2016)
Stefano Forli, Ruth Huey, Michael E Pique, Michel F Sanner, David S Goodsell, and Arthur J Olson.
Computational protein–ligand docking and virtual drug screening with the autodock suite.
*Nature protocols*, 11(5):905–919, 2016.
- (13)
Forli Lab, CCSB, D. Santos-Martins, J. Eberhardt, and S. Forli.
Meeko: Interface for AutoDock and RDKit.
[https://meeko.readthedocs.io/](https://meeko.readthedocs.io/) and [https://github.com/forlilab/Meeko](https://github.com/forlilab/Meeko).
Version 0.4.0, accessed 2025-09-11.
- Friesner et al. (2004)
Richard A Friesner, Jay L Banks, Robert B Murphy, Thomas A Halgren, Jasna J Klicic, Daniel T Mainz, Matthew P Repasky, Eric H Knoll, Mee Shelley, Jason K Perry, et al.
Glide: a new approach for rapid, accurate docking and scoring. 1. method and assessment of docking accuracy.
*Journal of medicinal chemistry*, 47(7):1739–1749, 2004.
- Hartshorn et al. (2007)
Michael J Hartshorn, Marcel L Verdonk, Gianni Chessari, Suzanne C Brewerton, Wijnand TM Mooij, Paul N Mortenson, and Christopher W Murray.
Diverse, high-quality test set for the validation of protein- ligand docking performance.
*Journal of medicinal chemistry*, 50(4):726–741, 2007.
- Hu et al. (2005)
Liegi Hu, Mark L Benson, Richard D Smith, Michael G Lerner, and Heather A Carlson.
Binding MOAD (mother of all databases).
*Proteins: Structure, Function, and Bioinformatics*, 60(3):333–340, 2005.
- Koes et al. (2013)
David Ryan Koes, Matthew P Baumgartner, and Carlos J Camacho.
Lessons learned in empirical scoring with SMINA from the CSAR 2011 benchmarking exercise.
*Journal of chemical information and modeling*, 53(8):1893–1904, 2013.
- Krivák and Hoksza (2018)
Radoslav Krivák and David Hoksza.
P2Rank: machine learning based tool for rapid and accurate prediction of ligand binding sites from protein structure.
*Journal of cheminformatics*, 10(1):39, 2018.
- Lai et al. (2024)
Houtim Lai, Longyue Wang, Ruiyuan Qian, Junhong Huang, Peng Zhou, Geyan Ye, Fandi Wu, Fang Wu, Xiangxiang Zeng, and Wei Liu.
Interformer: an interaction-aware model for protein-ligand docking and affinity prediction.
*Nature Communications*, 15(1):10223, 2024.
- Landrum (2024)
Greg Landrum.
RDKit: Open-Source Cheminformatics Software, 2024.
URL [https://github.com/rdkit/rdkit/releases/tag/Release_2024_09_1](https://github.com/rdkit/rdkit/releases/tag/Release_2024_09_1).
Release 2024_09_1.
- Le Guilloux et al. (2009)
Vincent Le Guilloux, Peter Schmidtke, and Pierre Tuffery.
Fpocket: an open source platform for ligand pocket detection.
*BMC bioinformatics*, 10(1):168, 2009.
- Lin et al. (2022)
Zeming Lin, Halil Akin, Roshan Rao, Brian Hie, Zhongkai Zhu, Wenting Lu, Allan dos Santos Costa, Maryam Fazel-Zarandi, Tom Sercu, Sal Candido, et al.
Language Models of Protein Sequences at the Scale of Evolution Enable Accurate Structure Prediction.
*bioRxiv*, 2022:500902, 2022.
- Lipman et al. (2022)
Yaron Lipman, Ricky TQ Chen, Heli Ben-Hamu, Maximilian Nickel, and Matt Le.
Flow matching for generative modeling.
*arXiv preprint arXiv:2210.02747*, 2022.
- Liu et al. (2017)
Zhihai Liu, Minyi Su, Li Han, Jie Liu, Qifan Yang, Yan Li, and Renxiao Wang.
Forging the basis for developing protein–ligand interaction scoring functions.
*Accounts of chemical research*, 50(2):302–309, 2017.
- Loshchilov and Hutter (2017)
Ilya Loshchilov and Frank Hutter.
Decoupled Weight Decay Regularization.
*arXiv preprint arXiv:1711.05101*, 2017.
- Lu et al. (2022)
Wei Lu, Qifeng Wu, Jixian Zhang, Jiahua Rao, Chengtao Li, and Shuangjia Zheng.
Tankbind: Trigonometry-aware neural networks for drug-protein binding structure prediction.
*Advances in neural information processing systems*, 35:7236–7249, 2022.
- Lu et al. (2024)
Wei Lu, Jixian Zhang, Weifeng Huang, Ziqiao Zhang, Xiangyu Jia, Zhenyu Wang, Leilei Shi, Chengtao Li, Peter G Wolynes, and Shuangjia Zheng.
DynamicBind: predicting ligand-specific protein-ligand complex structure with a deep equivariant generative model.
*Nature Communications*, 15(1):1071, 2024.
- McNutt et al. (2021)
Andrew T McNutt, Paul Francoeur, Rishal Aggarwal, Tomohide Masuda, Rocco Meli, Matthew Ragoza, Jocelyn Sunseri, and David Ryan Koes.
Gnina 1.0: molecular docking with deep learning.
*Journal of cheminformatics*, 13(1):43, 2021.
- Morehead and Cheng (2025)
Alex Morehead and Jianlin Cheng.
Flowdock: Geometric flow matching for generative protein-ligand docking and affinity prediction.
*ArXiv*, pages arXiv–2412, 2025.
- Morehead et al. (2025)
Alex Morehead, Nabin Giri, Jian Liu, Pawan Neupane, and Jianlin Cheng.
Deep learning for protein-ligand docking: Are we there yet?
*ArXiv*, pages arXiv–2405, 2025.
- Passaro et al. (2025)
Saro Passaro, Gabriele Corso, Jeremy Wohlwend, Mateo Reveiz, Stephan Thaler, Vignesh Ram Somnath, Noah Getz, Tally Portnoi, Julien Roy, Hannes Stark, et al.
Boltz-2: Towards accurate and efficient binding affinity prediction.
*BioRxiv*, pages 2025–06, 2025.
- Peebles and Xie (2023)
William Peebles and Saining Xie.
Scalable diffusion models with transformers.
In *Proceedings of the IEEE/CVF international conference on computer vision*, pages 4195–4205, 2023.
- Pei et al. (2023)
Qizhi Pei, Kaiyuan Gao, Lijun Wu, Jinhua Zhu, Yingce Xia, Shufang Xie, Tao Qin, Kun He, Tie-Yan Liu, and Rui Yan.
Fabind: Fast and accurate protein-ligand binding.
*Advances in Neural Information Processing Systems*, 36:55963–55980, 2023.
- Qiao et al. (2024a)
Zhuoran Qiao, Feizhi Ding, Thomas Dresselhaus, Mia A Rosenfeld, Xiaotian Han, Owen Howell, Aniketh Iyengar, Stephen Opalenski, Anders S Christensen, Sai Krishna Sirumalla, et al.
Neuralplexer3: Accurate biomolecular complex structure prediction with flow models.
*arXiv preprint arXiv:2412.10743*, 2024a.
- Qiao et al. (2024b)
Zhuoran Qiao, Weili Nie, Arash Vahdat, Thomas F Miller III, and Animashree Anandkumar.
State-specific protein–ligand complex structure prediction with a multiscale deep generative model.
*Nature Machine Intelligence*, 6(2):195–208, 2024b.
- Riniker and Landrum (2015)
Sereina Riniker and Gregory A Landrum.
Better informed distance geometry: using what we know to improve conformer generation.
*Journal of Chemical Information and Modeling*, 55(12):2562–2574, 2015.
doi: 10.1021/acs.jcim.5b00654.
- Shoemake (1985)
Ken Shoemake.
Animating rotation with quaternion curves.
In *Proceedings of the 12th annual conference on Computer graphics and interactive techniques*, pages 245–254, 1985.
- Stärk et al. (2022)
Hannes Stärk, Octavian Ganea, Lagnajit Pattanaik, Regina Barzilay, and Tommi Jaakkola.
Equibind: Geometric deep learning for drug binding structure prediction.
In *International conference on machine learning*, pages 20503–20521. PMLR, 2022.
- Sulimov et al. (2020)
Vladimir Sulimov, İvan Ilin, Danil Kutov, and Alexey Sulimov.
Development of docking programs for Lomonosov supercomputer.
*Journal of the Turkish Chemical Society Section A: Chemistry*, 7(1):259–276, 2020.
- Trott and Olson (2010)
Oleg Trott and Arthur J Olson.
AutoDock Vina: improving the speed and accuracy of docking with a new scoring function, efficient optimization, and multithreading.
*Journal of computational chemistry*, 31(2):455–461, 2010.
- Warner (1983)
Frank W Warner.
*Foundations of differentiable manifolds and Lie groups*, volume 94.
Springer Science & Business Media, 1983.
- Wohlwend et al. (2024)
Jeremy Wohlwend, Gabriele Corso, Saro Passaro, Mateo Reveiz, Ken Leidal, Wojtek Swiderski, Tally Portnoi, Itamar Chinn, Jacob Silterra, Tommi Jaakkola, et al.
Boltz-1: Democratizing biomolecular interaction modeling.
*bioRxiv*, pages 2024–11, 2024.
- Word et al. (1999)
J. M. Word, S. C. Lovell, J. S. Richardson, and D. C. Richardson.
Asparagine and glutamine: using hydrogen atom contacts in the choice of side-chain amide orientation.
*Journal of Molecular Biology*, 285(4):1735–1747, 1999.
doi: 10.1006/jmbi.1998.2401.
- Zhang et al. (2025a)
Kexin Zhang, Yuanyuan Ma, Jiale Yu, Huiting Luo, Jinyu Lin, Yifan Qin, Xiangcheng Li, Qian Jiang, Fang Bai, Jiayi Dou, et al.
PhysDock: A Physics-Guided All-Atom Diffusion Model for Protein-Ligand Complex Prediction.
*bioRxiv*, pages 2025–04, 2025a.
- Zhang et al. (2022)
Yangtian Zhang, Huiyu Cai, Chence Shi, Bozitao Zhong, and Jian Tang.
E3bind: An end-to-end equivariant network for protein-ligand docking.
*arXiv preprint arXiv:2210.06069*, 2022.
- Zhang et al. (2025b)
Zhijun Zhang, Lijun Quan, Junkai Wang, Liangchen Peng, Qiufeng Chen, Bei Zhang, Lexin Cao, Yelu Jiang, Geng Li, Liangpeng Nie, et al.
LABind: identifying protein binding ligand-aware sites via learning interactions between ligand and protein.
*Nature Communications*, 16(1):7712, 2025b.
- Zhou et al. (2023)
Gengmo Zhou, Zhifeng Gao, Qiankun Ding, Hang Zheng, Hongteng Xu, Zhewei Wei, Linfeng Zhang, and Guolin Ke.
Uni-Mol: A universal 3D molecular representation learning framework.
2023.

## Appendix

## Appendix A Flow matching on S ​ O ​ ( 2 ) SO(2) and S ​ O ​ ( 3 ) SO(3)

In this section, we address the problem of training flow matching on the special orthogonal groups $SO(2)$ and $SO(3)$. Our approach involves minimizing the flow matching loss function with respect to the parameters ${\bm{w}}$ of a flow model denoted by $v$. The loss function is defined as:

$$ $\ell({\bm{w}})=\mathbb{E}_{{\bm{x}}_{0},{\bm{x}}_{1},t}\left\|v({\bm{x}}(t),t;{\bm{w}})-\frac{\mathrm{d}{\bm{x}}(t)}{\mathrm{d}t}\right\|_{g},$ (4) $$

In the equation above, ${\bm{x}}(t)$ represents an interpolation between two points ${\bm{x}}_{0}$ and ${\bm{x}}_{1}$.
The term $\|{\bm{x}}\|_{g}=\sqrt{g({\bm{x}},{\bm{x}})}$ defines a norm based on the Riemannian metric $g$.

For a given Riemannian manifold $M$, the tangent space at a point $p\in M$ is denoted by $\mathcal{T}_{p}M$. The Riemannian metric is defined as:

$$ $g:\mathcal{T}_{p}M\times\mathcal{T}_{p}M\to\mathbb{R},$ (5) $$

acts on the Cartesian product of these tangent spaces to produce a non-negative scalar value.

The special orthogonal group $SO(n)$ consists of elements that can be represented as $n\times n$ rotation matrices.
Although there are several ways to define a Riemannian metric $g$ on $SO(n)$, the canonical metric is given by:

$$ $g(\mathbf{X},\mathbf{Y})\triangleq\mathrm{tr}(\mathbf{X}^{\top}\mathbf{Y}),$ (6) $$

where $\mathbf{X}$ and $\mathbf{Y}$ are $n\times n$ matrices corresponding to the elements of the tangent space.

Regarding interpolation on these manifolds, various methods exist.
In this work, we employ the widely used spherical linear interpolation, commonly referred to as SLERP Shoemake [1985].

### A.1 S ​ O ​ ( 2 ) SO(2) manifold

Every $2\times 2$ rotation matrix is characterized by the rotation angle $\theta$ and is given by

$$ $\mathbf{R}=\begin{bmatrix}\cos(\theta)&-\sin(\theta)\\ \sin(\theta)&\cos(\theta)\end{bmatrix}.$ (7) $$

Given two rotation matrices defined by angles $\theta_{0}$ and $\theta_{1}$, the SLERP interpolation between them for $t\in[0,1]$ is represented by the matrix $\mathbf{R}(t)$ with the angle

$$ $\theta(t)=\theta_{0}+t(\theta_{1}-\theta_{0})=\theta_{0}+t\Delta\theta.$ (8) $$

The time derivative of this matrix is

$$ $\dot{\mathbf{R}}(t)=\begin{bmatrix}-\sin(\theta(t))&-\cos(\theta(t))\\ \cos(\theta(t))&-\sin(\theta(t))\end{bmatrix}\Delta\theta,$ (9) $$

which can be expressed as

$$ $\dot{\mathbf{R}}(t)=\mathbf{R}(t)\begin{bmatrix}0&-\Delta\theta\\ \Delta\theta&0\end{bmatrix}.$ (10) $$

This form — a product of a rotation matrix and a skew-symmetric matrix — can be derived for any element of $SO(n)$, given that the tangent space of an identity $SO(n)$ matrix is spanned by skew-symmetric $n\times n$ matrices.

Assuming the neural network model $\hat{v}$ for the flow takes as input $\theta$ and $t$, and outputs a scalar $\hat{v}(\theta,t)$, we can represent the flow as

$$ $v(\mathbf{R}(t),t)=\mathbf{R}(t)\begin{bmatrix}0&-\hat{v}(\theta(t),t)\\ \hat{v}(\theta(t),t)&0\end{bmatrix}.$ (11) $$

Utilizing the canonical metric ([6](https://arxiv.org/html/2510.14586v2#A1.E6)), the norm difference becomes

$$ $\|v(\mathbf{R}(t),t)-\dot{\mathbf{R}}(t)\|=\sqrt{2}\left|\theta_{1}-\theta_{0}-\hat{v}(\theta(t),t)\right|.$ (12) $$

Consequently, our objective to be minimized is

$$ $\ell(\mathbf{w})=\mathbb{E}_{\theta_{0},\theta_{1},t}\left(\theta_{1}-\theta_{0}-\hat{v}(\mathbf{R}(t),t,\mathbf{w})\right)^{2}.$ (13) $$

### A.2 S ​ O ​ ( 3 ) SO(3) manifold

In contrast to $SO(2)$ case, SLERP for $3\times 3$ rotation matrices is more complicated, often requiring a transformation into quaternions [Brégier, 2021].
Nonetheless, it is possible to compute the interpolated matrix $\mathbf{R}(t)$ and its corresponding time derivative, which belongs to the tangent space of $\mathbf{R}(t)$, using automatic differentiation tools.

Every tangent vector of a point $\mathbf{R}\in SO(3)$ can be expressed as

$$ $\mathbf{R}\begin{bmatrix}0&-k_{z}&k_{y}\\ k_{z}&0&-k_{x}\\ -k_{y}&k_{x}&0\\ \end{bmatrix}.$ (14) $$

Assuming that the values $k_{x},k_{y},k_{z}$ describe the matrix $\dot{\mathbf{R}}(t)$, a neural network can be constructed to yield three outputs: $v_{x},v_{y},v_{z}$. The flow model becomes

$$ $v(\mathbf{R}(t),t)=\mathbf{R}(t)\begin{bmatrix}0&-v_{z}&v_{y}\\ v_{z}&0&-v_{x}\\ -v_{y}&v_{x}&0\\ \end{bmatrix}.$ (15) $$

For the $SO(3)$ manifold, the square of norm in equation ([4](https://arxiv.org/html/2510.14586v2#A1.E4)) evaluates to

$$ $2(k_{x}-v_{x})^{2}+2(k_{y}-v_{y})^{2}+2(k_{z}-v_{z})^{2}.$ (16) $$

To determine the values $k_{x},k_{y},k_{z}$, one can leverage automatic differentiation to compute $\dot{\mathbf{R}}(t)$. Subsequently, these values can be extracted from the expression $\mathbf{R}^{\top}(t)\dot{\mathbf{R}}(t)$.

## Appendix B How we run classical docking

##### Classical docking baseline parameters

We used AutoDock Vina (v1.2.5) [Trott and Olson, 2010], SMINA (v2020.12.10; fork of Vina 1.1.2) [Koes et al., 2013], and GNINA (v1.0.3) [McNutt et al., 2021].
Unless noted otherwise, all runs used exhaustiveness 64 and seed 42.
Pocket centers were provided as described below; the search box was centered at each pocket center and sized to the RDKit conformer diameter of the ligand plus a 10 Å padding on all six sides (equivalently, autobox_add 10 where applicable).
To emulate blind docking we also used a large box centered on the protein with padding autobox_add 16.

##### Ligand and receptor preparation for classical docking

Each ligand was prepared from a SMILES string: standardization and neutralization of charges, adjustment to pH 7 protonation rules, addition of explicit hydrogens, and 3D conformer generation with RDKit’s ETKDG method [Riniker and Landrum, 2015].
Receptor proteins were hydrogenated with Reduce (v4.13) using the FLIP option (Asparagine (Asn), Glutamine (Gln), Histidine (His) side-chain flips) [Word et al., 1999, Chen et al., 2010].
For AutoDock-family tools, inputs were converted to PDBQT with Meeko (v0.4.0) [Forli Lab, CCSB et al.,].

## Appendix C Extended results

### C.1 Blind docking

#### C.1.1 DockGen results

Figure: Figure 8: Blind ligand docking success rates on DockGen dataset ($n=330$).
Refer to caption: x8.png

We report blind docking success rates for Astex, PoseBusters V2 and PDBBind test sets in the main text in Section [4.1](https://arxiv.org/html/2510.14586v2#S4.SS1).
In Figure [8](https://arxiv.org/html/2510.14586v2#A3.F8), we present the results for DockGen test set, which contains proteins with pockets that are structurally dissimilar to the training set.
All considered models perform poorly on this set.
However, co-folding models show better results.
We explain it by the difference in training datasets: co-folding models have seen significantly more proteins during pre-training, which allows them to work better on the out-of-distribution proteins and ligands from the DockGen dataset.

#### C.1.2 Results with different pocket prediction methods

In this section, we report results for blind docking scenario for models that require pocket information as input: Uni-Mol, SMINA, VINA, GNINA.
We use three types of pocket information: P2Rank [Krivák and Hoksza, 2018], Fpocket [Le Guilloux et al., 2009] and full protein setup.
Full protein means providing the whole protein and the protein center as a starting pocket center: using large box centered on the protein with padding autobox_add 16.
The full protein setup was not used for Uni-Mol because this model is unable to process such type of inputs.

Figure: Figure 9: Blind ligand docking success rates with different pocket prediction methods on Astex Diverse set.
Refer to caption: x9.png

Figure: Figure 10: Blind ligand docking success rates with different pocket prediction methods on PDBBind test set.
Refer to caption: x10.png

Figure: Figure 11: Blind ligand docking success rates with different pocket prediction methods on PoseBusters V2 dataset.
Refer to caption: x11.png

Figure: Figure 12: Blind ligand docking success rates with different pocket prediction methods on DockGen dataset.
Refer to caption: x12.png

We report the results for all four considered tests datasets in Figures [9](https://arxiv.org/html/2510.14586v2#A3.F9), [10](https://arxiv.org/html/2510.14586v2#A3.F10), [11](https://arxiv.org/html/2510.14586v2#A3.F11), and [12](https://arxiv.org/html/2510.14586v2#A3.F12).
According to them, P2Rank consistently shows the best quality among all other pocket identification strategies.

### C.2 Pocket-aware docking

In addition to the blind docking setup, we run all models in the pocket-aware scenario, providing them with information about the true binding site (true ligand center).
This scenario imitates the real-world case with the desired pocket for the protein provided.
However, Uni-Mol cannot be fairly compared in the pocket-aware scenario due to its pocket cutting approach.
Unlike other docking methods that can flexibly utilize pocket information as a starting point, Uni-Mol uses the provided reference pocket center to cut a small fixed-radius pocket around the ligand.
This tight spatial constraint creates information leakage about the true ligand binding location, as the model becomes unable to ”forget” or deviate significantly from the provided center due to the severely limited protein context.
In contrast, methods like SMINA, VINA, GNINA, and Matcha treat pocket information as a flexible starting point: they can explore and modify the binding site during their search process.
Therefore, we do not report Uni-Mol results in the pocket-aware scenario.

In pocket-aware scenario with a known pocket center (stage 2 and stage 3 of Matcha), we outperform classical docking tools on Astex, PDBBind, DockGen, but have slightly lower scores on PoseBusters V2 due to the domain shift (Figures [14](https://arxiv.org/html/2510.14586v2#A3.F14), [14](https://arxiv.org/html/2510.14586v2#A3.F14), [16](https://arxiv.org/html/2510.14586v2#A3.F16), and  [16](https://arxiv.org/html/2510.14586v2#A3.F16)).

Figure: Figure 13: Pocket-aware ligand docking success rates on Astex Diverse set.
Refer to caption: x13.png

Figure: Figure 15: Pocket-aware ligand docking success rates on PoseBusters V2 set.
Refer to caption: x15.png

## Appendix D The importance of the pocket alignment

### D.1 Pocket-aligned RMSD computation

For all models that predict the structure of the whole complex, we follow Abramson et al. [2024] and use pocket-aligned symmetric RMSD.
However, since this procedure is not clearly defined in the paper, we explain in detail how we perform the base pocket alignment.

- 1.
The primary protein chain with the most atoms within 10 Å of the ligand is kept.
- 2.
The pocket is defined as all Cα atoms within 10 Å of any heavy atom of the reference ligand, restricted to protein backbone atoms.
- 3.
The reference pocket is aligned to the whole predicted protein structure by Cα atoms in PyMOL [DeLano et al., 2002] with five refinement cycles, which is the default parameter.

An alternative approach to compute pocket-aware RMSD was described in Qiao et al. [2024a].
This pocket-based approach shares the first two stages, but then the procedure differs:

- 3.
The predicted pocket is defined as all Cα atoms within 10 Å of any heavy atom of the predicted ligand, restricted to protein backbone atoms.
- 4.
Each chain in the predicted pocket is aligned to the reference pocket, and the chain with the minimum alignment RMSD is selected.
The alignment is performed with zero refinement cycles.

We believe the base approach provides fair evaluation, while the pocket-based approach produces overoptimistic results due to a fundamental flaw: for multi-chain proteins with multiple binding sites it can artificially align non-corresponding pockets with low RMSD by chance.
This allows predicted ligands to appear correctly positioned even when docked to entirely wrong pockets.

The pocket-based alignment artificially constrains translation error since pockets are pre-aligned, masking true docking failures that would be evident in blind docking scenarios.
In contrast, real-world docking can produce large translation errors when ligands bind to incorrect sites—a critical failure mode that pocket-based metrics cannot detect.

This methodological difference explains the discrepancy between our metrics and those reported for AlphaFold 3 in the NeuralPlexer 3 [Qiao et al., 2024a] paper on the PoseBusters V2 dataset.
To demonstrate this bias, we show that rigid docking approaches can achieve the same artificial metric improvements when evaluated using pocket-based alignment.
We demonstrate the comparison between the base and the pocket-based approaches in Appendix [D.2](https://arxiv.org/html/2510.14586v2#A4.SS2).

### D.2 Docking results for different ways of computing pocket-aligned RMSD

Figure: Figure 17: Comparison of pocket alignment strategies in blind docking scenario for Astex Diverse set.
Refer to caption: x17.png

Figure: Figure 18: Comparison of pocket alignment strategies in blind docking scenario for PDBBind test set.
Refer to caption: x18.png

Figure: Figure 19: Comparison of pocket alignment strategies in blind docking scenario for PoseBusters V2 dataset.
Refer to caption: x19.png

Figure: Figure 20: Comparison of pocket alignment strategies in blind docking scenario for DockGen dataset.
Refer to caption: x20.png

We computed docking quality metrics using both base and pocket-based approaches for structure prediction methods (AlphaFold 3, Boltz-2, Chai-1, NeuralPlexer, FlowDock) and rigid docking approaches (DiffDock, Matcha).
The results for all considered test datasets are shown in
Figures [17](https://arxiv.org/html/2510.14586v2#A4.F17), [18](https://arxiv.org/html/2510.14586v2#A4.F18), [19](https://arxiv.org/html/2510.14586v2#A4.F19), and [20](https://arxiv.org/html/2510.14586v2#A4.F20).
The obtained results reveal comparable metric inflation across all methods.
This applies to all four test sets.
The increase is around 15-20% in $\mathrm{RMSD}\leq$2\text{\,}\mathrm{\SIUnitSymbolAngstrom}$$ for the Astex dataset and around 10% for PoseBusters V2.
Lower increases for PDBBind and DockGen test sets are due to the use of the preprocessed dataset versions with the removed irrelevant chains provided by Corso et al. [2022].
Moreover, the choice of the alignment almost does not affect the ordering of the docking methods: all our claims done for the base alignment, still hold for the pocket-based alignment.
This demonstrates that the apparent superiority of co-folding methods in some evaluations may stem from evaluation methodology rather than genuine performance differences.

## Appendix E Inference speed comparison

**Table 1: Comparison of the average inference time for blind docking models (for Astex test set)**
| Method | Inference time (sec) |
| --- | --- |
| Matcha | 15 |
| DiffDock | 32 |
| NeuralPlexer | 65 |
| FlowDock | 39 |
| AlphaFold 3 | 392 |
| Chai-1 | 1638 |
| Boltz-2 | 1488 |

We report the average inference speed for all considered blind docking methods on one NVIDIA A100 40GB GPU.
We use Astex dataset to measure the time on it.
Time is reported only for model inference avoiding model loading.
Most docking models generate multiple poses and select a pose with the best score, so we measure the time required to sample all required poses.
The results are shown in Table [1](https://arxiv.org/html/2510.14586v2#A5.T1).

## Appendix F PoseBusters tests

We report PoseBusters results for the following 27 tests according to the release in [https://github.com/maabuu/posebusters/releases/tag/v0.4.5](https://github.com/maabuu/posebusters/releases/tag/v0.4.5):

- 1.
mol_pred_loaded,
- 2.
mol_cond_loaded,
- 3.
sanitization,
- 4.
inchi_convertible,
- 5.
all_atoms_connected,
- 6.
bond_lengths,
- 7.
bond_angles,
- 8.
internal_steric_clash,
- 9.
aromatic_ring_flatness,
- 10.
non-aromatic_ring_non-flatness,
- 11.
double_bond_flatness,
- 12.
internal_energy,
- 13.
protein-ligand_maximum_distance,
- 14.
minimum_distance_to_protein,
- 15.
minimum_distance_to_organic_cofactors,
- 16.
minimum_distance_to_inorganic_cofactors,
- 17.
minimum_distance_to_waters,
- 18.
volume_overlap_with_protein,
- 19.
volume_overlap_with_organic_cofactors,
- 20.
volume_overlap_with_inorganic_cofactors,
- 21.
volume_overlap_with_waters,
- 22.
double_bond_stereochemistry,
- 23.
mol_true_loaded,
- 24.
molecular_bonds,
- 25.
molecular_formula,
- 26.
$\mathrm{RMSD}\leq$2\text{\,}\mathrm{\SIUnitSymbolAngstrom}$$,
- 27.
tetrahedral_chirality.

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 4
presentation: 3
questions: 1.	The method relies on a post-processing filter to remove physically implausible poses. Does this mean that MATCHA's generative process routinely produces a large number of poses that do not conform to basic physicochemical principles?
2.	The method uses random rotations for data augmentation. Could this be replaced with an equivariant graph neural network?
3.	The algorithm description mentions that the final loss is a linear combination (a weighted sum) of the three components (translation, rotation, torsion). How were these weights determined?
4.	The inference process uses 10 fixed steps. What is the rationale for this?
soundness: 2
strengths: 1.	The paper is written in a standard and concise manner; the methods and experiments are easy to understand and unambiguous, and the experiments are fairly sufficient.
2.	The method is the first to apply Riemannian Flow Matching to the field of molecular docking, opening a new research direction with great potential for the field.
3.	The method pragmatically deconstructs the complex docking problem; through its "coarse-to-fine," three-stage pipeline design, it demonstrates an efficient framework for multi-scale generative tasks that is both reliable and original.
4.	The method achieves an excellent and practically significant balance between speed and accuracy. A major advantage of the model is its excellent ability to generate physically plausible conformations.
summary: This paper introduces MATCHA, a novel multi-stage pipeline for protein-ligand docking. The approach pioneers the use of Riemannian Flow Matching on non-Euclidean manifolds, structured within a coarse-to-fine framework. The method models the ligand's degrees of freedom across their corresponding geometric manifolds: translation in R 3, global rotation in SO(3), and internal torsions in SO(2)m. The pipeline employs three sequential, independently trained flow matching models to progressively refine the docking pose, progressing from a global translational search to fine-grained adjustments of all degrees of freedom. Architecturally, the model is based on a DiT-like structure, which incorporates spatial biases into its attention mechanism to effectively capture 3D geometric relationships. A separate scoring model and a physical validity filter are then used to screen the candidates and select the final pose. The authors demonstrate that their method achieves superior performance in terms of both docking success rate and physical plausibility. Furthermore, it operates approximately 25x faster than modern, large-scale co-folding models.
weaknesses: 1. The paper proposes a complex multi-stage pipeline (3 generative models + 1 scoring model) but does not provide ablation studies to prove the rationale for this design. It cannot be determined if all components are necessary.
2. The paper does not sufficiently discuss and evaluate the rigid protein assumption and the semi-flexible ligand treatment.
3. The loss function optimized by the flow matching generative process may not be strongly correlated with true binding affinity or pose correctness, and the three-stage design can easily lead to the propagation and amplification of errors stage by stage.
4. The multi-stage pipeline is quite engineered, and the training burden is also quite large. Training on existing datasets like PDBBind does not guarantee the method's generalizability, and the four test sets are not particularly convincing.
5. The evaluation metrics are overly reliant on RMSD; are there other metrics?

---

confidence: 3
contribution: 2
initial_rating: 4
presentation: 3
questions: See above
soundness: 3
strengths: 1.   The paper presents a novel and well-motivated application of Riemannian flow matching to the problem of molecular docking, which is a significant departure from the more common diffusion-based generative models.
2.   Extensive experiments are performed on various import benchmark. MATCHA demonstrates performance on the ASTEX and PDBBind test sets, outperforming many existing methods, especially on the combined metric of geometric accuracy and physical validity (RMSD ≤ 2Å & PB-valid).
3. The method is shown to be highly efficient, with an inference time approximately 25 times faster than large-scale co-folding models and a more efficient training process than other deep learning baselines.
summary: This paper introduces MATCHA, a novel multi-stage pipeline for molecular docking. The method utilizes Riemannian flow matching to progressively refine the ligand's pose across translation, rotation, and torsional degrees of freedom. The pipeline consists of three sequential flow matching models for coarse-to-fine refinement, a separate learned scoring model for ranking candidate poses, and unsupervised physical validity filters to eliminate unrealistic structures. The authors evaluate MATCHA on several standard benchmarks, claiming it achieves a state-of-the-art balance between accuracy, computational efficiency, and physical plausibility, being significantly faster than co-folding models.
weaknesses: 1.  The model's performance significantly decreases on benchmarks designed to test generalization, such as POSEBUSTERS V2 and DOCKGEN. While the authors acknowledge this, it remains a major limitation, suggesting the model may not perform reliably on novel protein targets that are structurally dissimilar from its training set.

2.  The source of performance improvement is not clearly isolated. The model is trained on an expanded dataset (PDBBind plus BINDING MOAD), which is larger than that used for some key baselines. The paper lacks an ablation study to disentangle the effects of the larger training set from the novel architecture. Furthermore, the contribution of the individual components of the three-stage pipeline is not validated, making it difficult to assess if all stages are necessary for the final performance.

3. The POSEBUSTERS benchmark was specifically constructed to evaluate the generalization of models trained on PDBBind. By adding the BINDING MOAD dataset to its training, MATCHA may have been exposed to data more similar to the test set, potentially inflating its generalization performance. A detailed analysis of the structural similarity between the added training data and the test sets is needed for a fairer assessment of the model's true generalization ability.

---

confidence: 4
contribution: 2
initial_rating: 6
presentation: 3
questions: - How did you ensure no overlap/near-overlap between MOAD training entries and PDBbind time-split test? Any interface-similarity or sequence-identity thresholds at the pocket? Will you release global dedup manifests?
- How sensitive is MATCHA to Euler step count, loss weights, and removing distance/direction biases? Does an equivariant variant help or hurt given the DiT choice?
- How do results change with alternate different packers, or AF-predicted pockets?
soundness: 4
strengths: - Clean formulation of flows on SO(2)/SO(3) with SLERP-based conditional velocities and a practical Euler rollout; torsion-only internal DOFs preserve bond geometry.
- Three independently trained stages (translation to refine translation/angles to sharpen all) are intuitive, grounded and effective.
- Competitive PB-valid success, clear speed/throughput analysis, and a lightweight scoring head geared for screening loops.
summary: The paper presents MATCHA, a three-stage rigid-receptor docking pipeline that performs Riemannian flow matching on translation, global rotation, and ligand torsions. A DiT-style backbone with distance/direction attention biases predicts velocity fields; a separate scoring model ranks candidates after unsupervised PoseBusters-style physical-validity filtering. On ASTEX and PDBbind-time splits, MATCHA reports strong RMSD & PB-valid rates and fast inference versus co-folding models. Performance drops on DOCKGEN and PoseBusters V2, where co-folding pretraining breadth helps OOD pockets. Training uses PDBbind + Binding MOAD, inference samples about 40 poses and selects after filtering + scoring
weaknesses: - DOCKGEN and PoseBusters V2 results drop. Analysis attributes this to co-folding pretraining breadth, but there’s no granular breakdown (pocket geometry shift, ligand size/rotor count, charge states, metal cofactors).
- While overall very sound, the proposed approach is incremental to existing paradigms.

---

confidence: 4
contribution: 1
initial_rating: 2
presentation: 3
questions: 1. Have the authors considered a more comprehensive comparison with other recent deep learning-based docking models?
2. What is the motivation for including an additional pose refinement model as the final step? How critical is it to overall performance?
soundness: 2
strengths: - Matcha decouples translation prediction for rotation & torsion prediction, enabling a natural extension to pocket-informed settings.
- The paper is clearly written and easy to follow.
summary: The paper presents Matcha, a Riemannian flow-based model that predicts the rotation, translation, and torsion angles of ligands. The authors aim to demonstrate that Matcha achieves a favorable speed–accuracy tradeoff, which is crucial in practical settings.
weaknesses: - Matcha can be viewed as a flow matching version of DiffDock with a DiT-style architecture, which limits its methodological novelty/contribution.
- While Matcha demonstrates fast inference speed and comparable results on Astex and PDBBind benchmarks, it demonstrates poor performance on PoseBusters V2 and DockGen benchmarks. 
- Matcha lacks several recent/important baselines, such as DiffDock-L, DynamicBind, SurfDock (i.e., those in [PoseX](https://arxiv.org/abs/2505.01700v2)). Incorporating these models could provide a more convincing evaluation of Matcha's performance.

---

confidence: 4
contribution: 2
initial_rating: 4
presentation: 3
questions: 1. Does Matcha's inference code support the prediction of multi-ligand docking targets?
soundness: 2
strengths: 1. Incorporating no geometric symmetries directly into Matcha's (DiT-based) model architecture is nice to see, following trends from recent works such as AlphaFold 3.
2. The authors' benchmarks are comprehensive and informative, following many best practices in the field.
3. Using the 35M parameter version of ESM to avoid overfitting is a clever idea. I haven't seen other works try this.
summary: The authors introduce Matcha, a Riemannian flow matching model for molecular docking, which achieves strong results in comprehensive benchmarks. By not directly incorporating geometric symmetries, Matcha's model architecture provides fast inference at scale. Nonetheless, a few concerns remain regarding the authors' evaluation and discussion of their proposed method.
weaknesses: 1. Matcha doesn't encode protein side-chain atoms, only carbon-alpha (Ca) atoms. This could fundamentally limit its applicability in atomically precise docking tasks such as protein cryptic pocket docking. It'd be good for the authors to discuss this limitation and how it might affect the interpretation of their docking results for Matcha.
2. The authors' analysis of the evaluation impact of using different alignment methods (in the appendix) is nice to see, but it still raises the question: "Why do Matcha's reported benchmarking metrics for the PoseBusters Benchmark (v2) dataset differ significantly from those reported in existing benchmarks such as those of AlphaFold 3 and PoseBench?". For example, PoseBench's reported docking success rates for NeuralPLexer and Chai-1 (using PyMOL for protein-ligand pocket-based alignment) are around 20% and 55%, respectively, whereas the success rates reported for them in this work are around 2% and 30%, respectively. This seems like a possible concern regarding whether these methods were (methodologically) evaluated correctly for such input data.


Decision: Reject