QUBODock: QUBO for Ligand Pose Generation

• QUBODock is a computational framework that reformulates ligand pose generation as a QUBO optimization problem, discretizing protein binding pockets into candidate grid points.
• It features a modular, Python-based workflow with GPU-accelerated solvers and command-line tools that facilitate integration with any external scoring method.
• The framework enhances reproducibility by decoupling pose enumeration from scoring, enabling benchmarking and method development in structure-based virtual screening.

QUBODock is a computational framework and software tool that formulates ligand pose generation as a Quadratic Unconstrained Binary Optimization (QUBO) problem, enabling pose enumeration for protein-ligand docking tasks. It is implemented in Python, accelerated via PyTorch on CPU or GPU, distributed as a pip-installable package on PyPI, and offers a transparent, reproducible workflow that deliberately excludes built-in scoring functions. Its design supports downstream coupling with any external scoring method, making it suited for research, benchmarking, and method development in virtual screening pipelines.

1. QUBO Model Construction for Ligand Pose Generation

QUBODock initializes the docking process by discretizing the binding pocket as a grid of candidate points within a user-defined spherical region on the protein structure. Each grid point is indexed by a binary variable $x_i \in \{0,1\}$, where $x_i=1$ denotes selection as a ligand placement site. The pose generation objective is encoded as a quadratic function over these binary variables:

$F(X) = X^{\mathrm{T}} J X$

with $X$ the vector of $x_i$ variables and $J$ a symmetric matrix of pairwise coupling weights reflecting geometric and compatibility constraints.

Pairwise couplings $J_{ij}$ are defined by inter-grid-point distances:

• If $d_{\text{min}} \leq d_{ij} \leq d_{\text{max}}$, $J_{ij} < 0$ encourages selection of well-separated, compatible pairs (attractive interaction).
• If $d_{ij} < d_{\text{min}}$, $J_{ij} > 0$ penalizes steric clashes.
• If $d_{ij} > d_{\text{max}}$, $J_{ij} \approx 0$ (neutral).

Grid resolution and the window $[d_{\text{min}}, d_{\text{max}}]$ are tunable, with finer grids yielding greater variable counts and higher granularity in pose selection. Steric exclusion against the protein is enforced by removing grid points too close to protein atoms prior to optimization.

2. Software Architecture and Solver Implementation

QUBODock is modularly architected around five small command-line programs that exchange data via plain-text files, permitting each processing stage to be individually inspected, replaced, or extended. The key stages are:

• Protein-ligand structure ingestion and preprocessing
• Grid generation
• QUBO model assembly
• Solution of the QUBO by built-in solver ("sa" for simulated annealing or "greedy" methods), with GPU acceleration available if PyTorch with CUDA is installed
• Decoding of QUBO solutions to enumerate candidate ligand poses

This modularity extends to the solver itself: external QUBO solvers, such as D-Wave quantum annealers or digital annealers, can be integrated with minor modification. The workflow is entirely command-line driven, and installation is performed with a single command:

pip install qubodock

3. Candidate Pose Decoding and Postprocessing

After solving the QUBO, the resulting vector $X$ identifies selected grid points. Pose enumeration proceeds by matching ligand atom triplets and corresponding grid points with compatible geometric arrangements. A rigid transform is computed for each candidate mapping, yielding a set of plausible ligand placements within the binding pocket.

Postprocessing includes:

• Filtration based on steric clash checks between the ligand and protein atoms
• Optional RMSD evaluation for benchmarking against experimental structures (if available)

Importantly, QUBODock does not provide built-in scoring; users must supply external scoring tools or custom heuristics for rank-ordering generated poses.

4. Applications, Use Cases, and Accessibility

QUBODock is specialized for structure-based virtual screening where the goal is to generate geometrically viable ligand poses for further ranking by advanced scoring functions or downstream workflows. Its minimal input requirements (protein PDB file, ligand PDB file), transparent command-line tools, and modular text-file interfaces facilitate:

• Method benchmarking and reproducibility studies in QUBO docking algorithms
• Teaching, owing to the clear illustration of QUBO model construction and pose generation
• Integration into customizable research pipelines where candidate generation is decoupled from the scoring methodology

Users may leverage the flexibility of external scoring tools (ML-based, physics-based, empirical) to investigate alternative ranking schemes or assess novel protein-ligand pose generation methods.

5. Comparison with Other Computational Docking Approaches

A distinguishing feature of QUBODock is its strict separation of pose generation (via constraint-driven QUBO optimization) from any built-in scoring functionality. This contrasts with traditional docking programs that encapsulate candidate generation and scoring in a monolithic package. QUBODock’s geometric constraint-based QUBO formulation offers interpretability and reproducibility. GPU acceleration and the command-line modularity distinguish it from less transparent or less customizable tools.

The intentional absence of an internal scoring mechanism is a design choice to foster interoperability, method development, and unbiased benchmarking in QUBO-based docking workflows.

6. Practical Considerations and Limitations

QUBODock requires Python $>$3.8 and a compatible PyTorch installation. Grid sizing and distance window parameters must be appropriately chosen to balance computational tractability and pose coverage. The tool is restricted to pose generation and does not optimize for energetic or biochemical criteria unless such evaluations are performed independently as a downstream analysis. Its utility is maximized in advanced screening workflows where researchers wish to explicitly decouple candidate enumeration from pose ranking, or explore QUBO-based optimization methods in a reproducible fashion.

A plausible implication is that QUBODock will facilitate experimentation with novel scoring paradigms, hybrid classical-quantum workflows, and method development around QUBO-encoded constraint satisfaction docking approaches.