Molecular Docking via DC-QAOA

Pose a drug-binding problem as a weighted graph clique search and solve it with Digitized Counterdiabatic QAOA, which adds counterdiabatic driving for faster convergence.

The problem it solves

Molecular docking asks how a small molecule (a candidate drug, the ligand) fits into a protein's binding site, and how strongly it binds. The space of possibilities is combinatorial: there are enormously many ways to position, orient, and flex the ligand, and to pair up its chemical groups with complementary spots on the protein. Scoring every arrangement exhaustively is hopeless, so docking is fundamentally a hard combinatorial optimization problem — and this kind of discretized combinatorial optimization is well suited to modeling and exploration with variational quantum optimizers like QAOA.

From docking to a graph problem

The standard reformulation turns docking into a graph. Each candidate ligand–protein contact (a specific chemical group sitting at a specific pocket location) becomes a vertex, weighted by how favourable that contact is. Two contacts are joined by an edge when they are mutually compatible — geometrically consistent, not clashing. A valid binding pose is then a set of contacts that are all pairwise compatible, i.e. a clique in this graph, and the best pose is the maximum-weight clique: the mutually consistent set of contacts with the highest total interaction strength.

The cost Hamiltonian — QUBO and Ising

To run this on a quantum computer, assign one binary variable (one qubit) to each candidate contact: xi = 1 if the contact is included in the pose, 0 otherwise. Write a cost function that is a QUBO (quadratic unconstrained binary optimization): if edges encode compatibility, the QUBO rewards the weights of selected vertices and adds a penalty for pairs of vertices not joined by a compatibility edge, preventing incompatible contacts from being chosen together. Substituting xi → (1 − Zi)/2 turns the QUBO into a diagonal Ising cost Hamiltonian HC whose lowest-energy computational-basis state encodes exactly the maximum-weight clique. To turn the maximization into a ground-state search, the reward terms are written as negative energy, i.e. minimize "negative clique weight + incompatibility penalty". Solving the docking problem is now: find the ground state of HC.

QAOA with counterdiabatic driving

QAOA approximates that ground state by alternating two kinds of layer: a cost layer e−iγHC that imprints the problem's energy as phases, and a mixer layer e−iβHM that drives transitions between candidate solutions. Tuning the angles (γ, β) steers the state toward low cost. Plain QAOA needs many layers — deep circuits — to mimic a slow adiabatic sweep. Digitized counterdiabatic QAOA (DC-QAOA) adds an extra driving term that approximately cancels the diabatic transitions an over-fast sweep would cause, so good solutions emerge at shallower depth — a real advantage on near-term hardware.

Seeing it in code

Read the kernel against the layers above. h(q) prepares the uniform superposition over all candidate inclusion patterns; the cost layer (commented) applies HC built from the clique weights; here a single-qubit Y rotation ry(alphas[l], q[i]) is used as a simplified approximation of the counter-diabatic drive — in real DC-QAOA the form of the counter-diabatic term depends on the chosen approximation and the problem Hamiltonian; and rx(2.0 * betas[l], q[i]) is the standard mixer. The three angle arrays gammas, betas, alphas are what a classical optimizer tunes.

DC-QAOA kernel

import qalgora

@qalgora.kernel
def dc_qaoa(gammas: list[float], betas: list[float],
            alphas: list[float], layers: int, n: int):
    q = qalgora.qvector(n)
    h(q)
    for l in range(layers):
        # cost layer (clique weights) ...
        # counterdiabatic term: extra Y-rotations speed convergence
        for i in range(n):
            ry(alphas[l], q[i])
        # mixer layer
        for i in range(n):
            rx(2.0 * betas[l], q[i])
    mz(q)

Honest limits

• It is a heuristic. QAOA gives no guarantee of finding the true maximum-weight clique; like all variational methods, the result depends on depth, the optimizer, and the landscape.
• One qubit per contact caps the scale. The QUBO needs a qubit for every candidate contact, so realistic docking problems quickly exceed near-term qubit counts — this is a proof-of-concept formulation, not a production docking engine.
• Counterdiabatic terms are approximate. The added driving only approximately suppresses diabatic transitions; it reduces the required depth but does not make the result exact.
• Classical methods are strong competitors. Well-tuned classical solvers handle clique and QUBO problems at this scale very effectively, so the quantum approach must be judged honestly against them.