---
profile: elgora_markdown_bounty_challenge_v1
escrow_amount: "20000000"
submission_deadline: 1795219140
payout_policy: winner_take_all
---

# Lowest MMFF94s Conformer of a 21-Rotatable-Bond Achiral Foldamer

## Summary
Find the lowest-energy three-dimensional conformer of one specified flexible molecule under the MMFF94s force field, and submit the structure. Checking a Submission takes a few seconds on any laptop; finding a good structure is a global optimisation over roughly twenty-one coupled torsions with eight competing hydrogen-bond donors, and better answers come from more search and better search. The lowest verified energy wins.

## Challenge details
The target molecule is the achiral octameric foldamer given by this SMILES string, which is the RDKit canonical form:

```
COc1ccc(CNC(=O)CNC(=O)CCNC(=O)CNC(=O)CCCNC(=O)CNC(=O)CCNC(=O)CNC(C)=O)cc1
```

It is C28H42N8O9, molecular weight 634.69, 45 heavy atoms and 87 atoms with hydrogens explicit, 21 rotatable bonds, 8 hydrogen-bond donors, and no stereocentres and no stereogenic double bonds. Being achiral, it has no stereochemistry to preserve or report.

**The objective.** Produce a single 3D conformer of exactly this molecule whose MMFF94s potential energy is as low as possible. Energy means the gas-phase MMFF94s single-point potential energy in kcal/mol, computed from the submitted coordinates by RDKit exactly as the reference verifier below computes it. There is no solvent model, no entropy or temperature term, no ensemble average: one structure, one number, lower is better.

**Why the energy is hard to drive down.** The backbone alternates glycine, beta-alanine and GABA-type spacers, so the torsional space is large and the amide N-H and C=O groups can satisfy each other in many mutually exclusive hydrogen-bonding patterns. Low-lying minima are separated by barriers that simple random conformer generation crosses only by luck, and the energy keeps improving well past the point where naive sampling stops helping.

**Any method is allowed.** Random or systematic conformer generation, molecular dynamics, simulated annealing, basin hopping, low-mode search, metadynamics, semi-empirical or quantum geometry optimisation, machine-learned potentials, commercial conformational search software, GPU-batched minimisation, or hand-building a structure from chemical intuition are all acceptable, alone or combined. A structure found with any other method and then relaxed into an MMFF94s minimum is a valid Submission. Only the final submitted coordinates are judged, never the route taken to them.

**A calibration point, measured on one CPU core.** Generating 200 conformers with RDKit ETKDGv3 and minimising them with MMFF94s takes about one minute and lands between roughly -90 and -95 kcal/mol, varying by several kcal/mol with the random seed. That is the scale of effort the qualifying bar is set just beyond. It is not the scale of effort expected to win.

## What you need to submit (Deliverables)
Three required files at the Submission root. Additional files may be included; they are ignored.

| Deliverable | Required or optional | Required content | Format requirements | Purpose |
|---|---|---|---|---|
| `conformer.sdf` | Required | Exactly one 3D conformer of the target molecule, hydrogens explicit, as a single record | MDL molfile or SDF readable by `rdkit.Chem.MolFromMolFile` with `removeHs=False` and sanitisation on; coordinates in angstroms | The structure that is scored |
| `result.json` | Required | A JSON object with the key `energy_kcal_per_mol` whose value is the MMFF94s single-point energy of `conformer.sdf` as a number | UTF-8 JSON object | States the claimed score, and is cross-checked against the recomputed value |
| `method.md` | Required | UTF-8 Markdown file describing the software and versions used, the search method, and the approximate compute spent in core-hours or GPU-hours. **Its presence is checked and its content is read, but never parsed or enforced by the verifier** | UTF-8 Markdown | Records how the result was obtained; its content is not scored or ranked |

## Inputs, Materials and References
The SMILES string in Challenge details is the only input. Nothing needs to be downloaded.

**Reference environment.** RDKit 2026.09.2, installed with `pip install rdkit`, on CPython 3.11 or newer. MMFF94s single-point energies in RDKit are deterministic double-precision arithmetic: the same coordinates give the same energy to ten decimal places on repeated evaluation, and writing a structure to a molfile and reading it back does not change the energy, because molfile coordinates and the structure already agree to four decimal places.

**Reference verifier.** This script defines acceptance and scoring exactly. Run it as `python3 check_submission.py <submission_dir>`. It prints a JSON object and exits 0 for an accepted Submission.

```python
#!/usr/bin/env python3
import sys, json, itertools, os
from rdkit import Chem
from rdkit.Chem import AllChem

TARGET = "COc1ccc(CNC(=O)CNC(=O)CCNC(=O)CNC(=O)CCCNC(=O)CNC(=O)CCNC(=O)CNC(C)=O)cc1"
QUALIFY = -95.0
E_TOL = 0.05
MIN_DROP = 0.10

def energy(mol):
    props = AllChem.MMFFGetMoleculeProperties(mol, mmffVariant="MMFF94s")
    if props is None:
        return None
    return AllChem.MMFFGetMoleculeForceField(mol, props).CalcEnergy()

def main(d):
    fail = []
    sdf, res = os.path.join(d, "conformer.sdf"), os.path.join(d, "result.json")
    for p in (sdf, res, os.path.join(d, "method.md")):
        if not os.path.isfile(p):
            fail.append("missing " + os.path.basename(p))
    if fail:
        return 1, fail, None

    mol = Chem.MolFromMolFile(sdf, removeHs=False, sanitize=True)
    if mol is None:
        return 1, ["conformer.sdf does not parse"], None
    if mol.GetNumConformers() != 1 or not mol.GetConformer().Is3D():
        fail.append("not exactly one 3D conformer")
    if not any(a.GetAtomicNum() == 1 for a in mol.GetAtoms()):
        fail.append("hydrogens are not explicit")

    got = Chem.MolToSmiles(Chem.RemoveHs(mol))
    want = Chem.MolToSmiles(Chem.MolFromSmiles(TARGET))
    if got != want:
        fail.append("wrong molecule: " + got)

    e0 = energy(mol)
    if e0 is None:
        return 1, fail + ["MMFF94s cannot parameterise it"], None

    m2 = Chem.Mol(mol)
    AllChem.MMFFOptimizeMolecule(m2, mmffVariant="MMFF94s", maxIters=20000)
    drop = e0 - energy(m2)
    if drop > MIN_DROP:
        fail.append("not a local minimum (drops %.3f)" % drop)
    if e0 > QUALIFY:
        fail.append("energy %.4f above qualifying bar %.1f" % (e0, QUALIFY))

    conf = mol.GetConformer()
    pts = [conf.GetAtomPosition(i) for i in range(mol.GetNumAtoms())]
    if min(pts[i].Distance(pts[j])
           for i, j in itertools.combinations(range(len(pts)), 2)) < 0.5:
        fail.append("atoms closer than 0.5 A")

    try:
        claimed = float(json.load(open(res))["energy_kcal_per_mol"])
        if abs(claimed - e0) > E_TOL:
            fail.append("claimed %.4f vs recomputed %.4f" % (claimed, e0))
    except Exception as exc:
        fail.append("result.json unusable: %s" % exc)

    return (0 if not fail else 1), fail, round(e0, 4)

if __name__ == "__main__":
    code, fail, e = main(sys.argv[1])
    print(json.dumps({"accepted": code == 0,
                      "score_kcal_per_mol": e,
                      "failures": fail}, indent=1))
    sys.exit(code)
```

## Acceptance Criteria
**These Acceptance Criteria are exactly the checks the reference verifier performs**; the verifier's verdict, not any stricter reading of the prose, controls. A Submission is accepted when the reference verifier above, run on the Submission root in the reference environment, exits 0 and reports no failures. Equivalently, all of the following hold.

1. **Files.** `conformer.sdf`, `result.json` and `method.md` are all present at the Submission root. (The verifier checks existence only; see criterion 8.)
2. **Structure.** `conformer.sdf` parses via `rdkit.Chem.MolFromMolFile` with `removeHs=False` and sanitisation on, which reads the first molfile record; the file carries at least one conformer and that conformer is three-dimensional; and at least one atom is an explicit hydrogen. (Additional SDF records, if any, are ignored; hydrogens need not all be explicit, but any hydrogens left implicit do not count as atoms.)
3. **Identity.** The canonical SMILES of the submitted structure with hydrogens removed equals the canonical SMILES of the target. This fixes the molecule, including its bonding pattern, tautomer and protonation state.
4. **Local minimum.** Further MMFF94s minimisation of the submitted coordinates lowers the energy by no more than 0.10 kcal/mol. A structure that has not been relaxed to a minimum is not accepted.
5. **Geometry sanity.** No two atoms are closer than 0.5 angstrom.
6. **Honest reporting.** The value of `energy_kcal_per_mol` in `result.json` is within 0.05 kcal/mol of the energy recomputed from the submitted coordinates.
7. **Qualifying bar.** The recomputed MMFF94s single-point energy is at most -95.0 kcal/mol.

The recomputed energy, not the claimed one, is the Submission's score throughout.

For the avoidance of doubt: the verifier enforces exactly criteria 1–7 and nothing else. Points in the Deliverables and Challenge details prose that the verifier does not machine-check — the content of `method.md`, that *all* hydrogens be explicit atoms, and that `conformer.sdf` contain a single molfile record — remain recommended good practice for a well-formed submission but cannot change acceptance.

## How is the winner selected?
Among accepted Submissions, the winner is the one with the lowest recomputed MMFF94s single-point energy in kcal/mol. Lower wins; there is no other criterion, and `method.md` is read but never ranked.

If several accepted Submissions are within 0.01 kcal/mol of one another at the top — concretely: let E be the lowest recomputed energy among accepted Submissions; the tie set is every accepted Submission whose recomputed energy is at most E + 0.01 kcal/mol — then they count as tied, and the winner is the Submission in that tie set recorded earliest on ElgoraHub, by block number and then by earlier transaction within a block. Where a Solver replaced an earlier Submission, the time the judged version was recorded is the one that counts.

If exactly one Submission is accepted, it wins. If none is accepted, the outcome is no valid submission.

## Out Of Scope
Any force field or energy model other than MMFF94s as implemented in RDKit; solvation, entropy, free energy or ensemble properties; any molecule other than the target, including isomers, tautomers, salts and isotopologues; submitting more than one conformer for scoring; and the quality, novelty or efficiency of the search method, which is recorded but never ranked.
