Upload folder using huggingface_hub

code/action_executor.py

@@ -0,0 +1,654 @@
+"""
+ActionExecutor — general-purpose molecular editing via a clean JSON Action protocol.
+
+Design:
+  - Graph-level: ChangeAtom, AddAtom, RemoveAtom, ChangeBond, AddBond, RemoveBond
+  - Shorthand:   AddGroup, RemoveGroup
+  - Stereo:      FlipChirality, FlipEZ
+  - Semantic:    MoveSubstituent, SwapSubstituents
+  - Composite:   Batch
+
+AtomRef (how to select an atom in the input SMILES):
+    {"map_num": 5}                        atom map number  (preferred)
+    {"smarts":  "[NH2]", "match_idx": 0}  SMARTS pattern   (most flexible)
+    {"idx":     3}                        raw atom index   (fragile)
+
+BondRef:
+    {"atom1": <AtomRef>, "atom2": <AtomRef>}
+
+Usage:
+    ex = ActionExecutor()
+    new_smiles = ex.execute("CCO", {"type": "ChangeAtom", "atom": {"idx": 2}, "element": "N"})
+    # → "CCN"
+"""
+
+import copy
+import sys, os
+sys.path.insert(0, os.path.dirname(__file__))
+
+from rdkit import Chem
+from rdkit.Chem import rdmolops
+from rdkit import RDLogger
+RDLogger.DisableLog("rdApp.*")
+
+from mol_ops import (
+    BOND_TYPE_MAP, ELEM_TO_NUM,
+    add_functional_group, remove_functional_group, flip_ez,
+)
+
+
+# ---------------------------------------------------------------------------
+# Exceptions
+# ---------------------------------------------------------------------------
+
+class ActionError(Exception):
+    """Base class for all executor errors."""
+
+class AtomNotFoundError(ActionError):
+    """Raised when an AtomRef cannot be resolved."""
+
+class BondNotFoundError(ActionError):
+    """Raised when a BondRef cannot be resolved."""
+
+class InvalidMolError(ActionError):
+    """Raised when an operation produces an invalid molecule."""
+
+class UnknownActionError(ActionError):
+    """Raised for unsupported action types."""
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+BOND_STEREO_MAP = {
+    "E":   Chem.BondStereo.STEREOE,
+    "Z":   Chem.BondStereo.STEREOZ,
+    "CIS": Chem.BondStereo.STEREOZ,
+    "TRANS": Chem.BondStereo.STEREOE,
+    "NONE": Chem.BondStereo.STEREONONE,
+}
+
+
+def _sanitize(rw, context=""):
+    try:
+        Chem.SanitizeMol(rw)
+    except Exception as e:
+        raise InvalidMolError(f"Sanitization failed{' (' + context + ')' if context else ''}: {e}")
+
+
+def _reset_atom_hs(atom):
+    """Clear explicit Hs and radical state so SanitizeMol recomputes implicit Hs."""
+    atom.SetNumExplicitHs(0)
+    atom.SetNoImplicit(False)
+    atom.SetNumRadicalElectrons(0)
+
+
+def _kekulize_rw(rw: Chem.RWMol) -> Chem.RWMol:
+    """Return a copy with aromatic bonds replaced by explicit single/double (Kekulé form)."""
+    rw2 = Chem.RWMol(copy.deepcopy(rw))
+    Chem.Kekulize(rw2, clearAromaticFlags=True)
+    return rw2
+
+
+def _to_canonical(mol):
+    for a in mol.GetAtoms():
+        a.SetAtomMapNum(0)
+    return Chem.MolToSmiles(mol)
+
+
+def _shared_rings(mol, idx1, idx2):
+    """Return set of ring-atom-index sets that contain both idx1 and idx2."""
+    ri = mol.GetRingInfo()
+    return [r for r in ri.AtomRings() if idx1 in r and idx2 in r]
+
+
+# ---------------------------------------------------------------------------
+# ActionExecutor
+# ---------------------------------------------------------------------------
+
+class ActionExecutor:
+    """
+    Apply a JSON Action to a SMILES string and return the modified SMILES.
+
+    Public API:
+        execute(smiles, action)          → str
+        execute_batch(smiles, actions)   → str
+    """
+
+    # ── Atom / Bond resolution ───────────────────────────────────────────────
+
+    def _resolve_atom(self, mol, ref: dict) -> int:
+        """Resolve an AtomRef dict to a concrete atom index in mol."""
+        if "map_num" in ref:
+            mn = ref["map_num"]
+            for a in mol.GetAtoms():
+                if a.GetAtomMapNum() == mn:
+                    return a.GetIdx()
+            raise AtomNotFoundError(f"No atom with map_num={mn}")
+
+        if "smarts" in ref:
+            patt = Chem.MolFromSmarts(ref["smarts"])
+            if patt is None:
+                raise AtomNotFoundError(f"Invalid SMARTS: {ref['smarts']!r}")
+            matches = mol.GetSubstructMatches(patt)
+            mi = ref.get("match_idx", 0)
+            if not matches or mi >= len(matches):
+                raise AtomNotFoundError(
+                    f"SMARTS {ref['smarts']!r} match_idx={mi}: "
+                    f"found {len(matches)} match(es)"
+                )
+            return matches[mi][0]
+
+        if "idx" in ref:
+            idx = ref["idx"]
+            if idx < 0 or idx >= mol.GetNumAtoms():
+                raise AtomNotFoundError(f"idx={idx} out of range (mol has {mol.GetNumAtoms()} atoms)")
+            return idx
+
+        raise AtomNotFoundError(f"AtomRef must have 'map_num', 'smarts', or 'idx': got {ref}")
+
+    def _resolve_bond(self, mol, bond_ref: dict):
+        """Resolve a BondRef to (idx1, idx2, Bond)."""
+        i1 = self._resolve_atom(mol, bond_ref["atom1"])
+        i2 = self._resolve_atom(mol, bond_ref["atom2"])
+        bond = mol.GetBondBetweenAtoms(i1, i2)
+        if bond is None:
+            raise BondNotFoundError(f"No bond between atom idx {i1} and {i2}")
+        return i1, i2, bond
+
+    # ── Action handlers ──────────────────────────────────────────────────────
+
+    def _change_atom(self, rw: Chem.RWMol, action: dict):
+        idx = self._resolve_atom(rw, action["atom"])
+        atom = rw.GetAtomWithIdx(idx)
+
+        if "element" in action:
+            n = ELEM_TO_NUM.get(action["element"])
+            if n is None:
+                raise ActionError(f"Unknown element: {action['element']!r}")
+            atom.SetAtomicNum(n)
+            atom.SetNoImplicit(False)
+
+        if "charge" in action:
+            atom.SetFormalCharge(int(action["charge"]))
+            _reset_atom_hs(atom)
+
+        if "isotope" in action and action["isotope"] is not None:
+            atom.SetIsotope(int(action["isotope"]))
+
+        if "num_hs" in action and action["num_hs"] is not None:
+            atom.SetNumExplicitHs(int(action["num_hs"]))
+            atom.SetNoImplicit(True)
+
+        atom.UpdatePropertyCache(strict=False)
+        _sanitize(rw, "ChangeAtom")
+        return rw
+
+    def _add_atom(self, rw: Chem.RWMol, action: dict):
+        anchor_idx = self._resolve_atom(rw, action["anchor"])
+        elem = action["element"]
+        n = ELEM_TO_NUM.get(elem)
+        if n is None:
+            raise ActionError(f"Unknown element: {elem!r}")
+
+        order = action.get("bond_order", "SINGLE").upper()
+        bond_type = BOND_TYPE_MAP.get(order)
+        if bond_type is None:
+            raise ActionError(f"Unknown bond order: {order!r}")
+
+        new_idx = rw.AddAtom(Chem.Atom(n))
+        new_atom = rw.GetAtomWithIdx(new_idx)
+
+        if "charge" in action:
+            new_atom.SetFormalCharge(int(action["charge"]))
+        if "num_hs" in action and action["num_hs"] is not None:
+            new_atom.SetNumExplicitHs(int(action["num_hs"]))
+
+        _reset_atom_hs(rw.GetAtomWithIdx(anchor_idx))
+
+        rw.AddBond(anchor_idx, new_idx, bond_type)
+        _sanitize(rw, "AddAtom")
+        return rw
+
+    def _remove_atom(self, rw: Chem.RWMol, action: dict):
+        idx = self._resolve_atom(rw, action["atom"])
+        neighbors = [n.GetIdx() for n in rw.GetAtomWithIdx(idx).GetNeighbors()]
+        rw.RemoveAtom(idx)
+        for nidx in neighbors:
+            adj = nidx if nidx < idx else nidx - 1
+            if adj < rw.GetNumAtoms():
+                _reset_atom_hs(rw.GetAtomWithIdx(adj))
+        _sanitize(rw, "RemoveAtom")
+        return rw
+
+    def _change_bond(self, rw: Chem.RWMol, action: dict):
+        i1, i2, bond = self._resolve_bond(rw, action["bond"])
+        order = action["order"].upper()
+        bond_type = BOND_TYPE_MAP.get(order)
+        if bond_type is None:
+            raise ActionError(f"Unknown bond order: {order!r}")
+        bond.SetBondType(bond_type)
+
+        if "stereo" in action and action["stereo"]:
+            stereo = BOND_STEREO_MAP.get(action["stereo"].upper())
+            if stereo is not None:
+                bond.SetStereo(stereo)
+
+        for idx in (i1, i2):
+            _reset_atom_hs(rw.GetAtomWithIdx(idx))
+        _sanitize(rw, "ChangeBond")
+        return rw
+
+    def _add_bond(self, rw: Chem.RWMol, action: dict):
+        i1 = self._resolve_atom(rw, action["bond"]["atom1"])
+        i2 = self._resolve_atom(rw, action["bond"]["atom2"])
+        if rw.GetBondBetweenAtoms(i1, i2) is not None:
+            raise ActionError(f"Bond already exists between atoms {i1} and {i2}")
+        order = action.get("order", "SINGLE").upper()
+        bond_type = BOND_TYPE_MAP.get(order)
+        if bond_type is None:
+            raise ActionError(f"Unknown bond order: {order!r}")
+        rw.AddBond(i1, i2, bond_type)
+        for idx in (i1, i2):
+            _reset_atom_hs(rw.GetAtomWithIdx(idx))
+        _sanitize(rw, "AddBond")
+        return rw
+
+    def _remove_bond(self, rw: Chem.RWMol, action: dict):
+        i1, i2, _ = self._resolve_bond(rw, action["bond"])
+        rw.RemoveBond(i1, i2)
+        for idx in (i1, i2):
+            _reset_atom_hs(rw.GetAtomWithIdx(idx))
+        _sanitize(rw, "RemoveBond")
+        return rw
+
+    def _add_group(self, rw: Chem.RWMol, action: dict):
+        anchor = self._resolve_atom(rw, action["anchor"])
+        group  = action["group"]
+        result = add_functional_group(rw, anchor_idx=anchor, group_name=group)
+        if result is None:
+            raise InvalidMolError(f"AddGroup failed: group={group!r} anchor={anchor}")
+        return Chem.RWMol(result)
+
+    def _remove_group(self, rw: Chem.RWMol, action: dict):
+        anchor = self._resolve_atom(rw, action["anchor"])
+        group  = action["group"]
+        result, removed = remove_functional_group(rw, anchor_idx=anchor, group_name=group)
+        if result is None:
+            raise InvalidMolError(
+                f"RemoveGroup failed: group={group!r} not found at anchor={anchor}"
+            )
+        rw2 = Chem.RWMol(result)
+        _reset_atom_hs(rw2.GetAtomWithIdx(anchor))
+        _sanitize(rw2, "RemoveGroup")
+        return rw2
+
+    def _flip_chirality(self, rw: Chem.RWMol, action: dict):
+        idx = self._resolve_atom(rw, action["atom"])
+        atom = rw.GetAtomWithIdx(idx)
+        chi = atom.GetChiralTag()
+        if chi == Chem.ChiralType.CHI_TETRAHEDRAL_CW:
+            atom.SetChiralTag(Chem.ChiralType.CHI_TETRAHEDRAL_CCW)
+        elif chi == Chem.ChiralType.CHI_TETRAHEDRAL_CCW:
+            atom.SetChiralTag(Chem.ChiralType.CHI_TETRAHEDRAL_CW)
+        else:
+            raise ActionError(f"Atom idx={idx} has no specified chirality to flip")
+        _sanitize(rw, "FlipChirality")
+        return rw
+
+    def _flip_ez(self, smiles: str, action: dict) -> str:
+        """
+        FlipEZ: invert E/Z at SMILES level.
+        If 'bond' is provided, validates it's a double bond first.
+        """
+        mol = Chem.MolFromSmiles(smiles)
+        if mol is None:
+            raise InvalidMolError(f"Cannot parse SMILES: {smiles!r}")
+
+        if "bond" in action:
+            i1, i2, bond = self._resolve_bond(mol, action["bond"])
+            if bond.GetBondType() != Chem.BondType.DOUBLE:
+                raise ActionError(
+                    f"FlipEZ: bond between atoms {i1} and {i2} is not a double bond"
+                )
+
+        smi = Chem.MolToSmiles(mol, isomericSmiles=True)
+        if "/" not in smi and "\\" not in smi:
+            raise ActionError("FlipEZ: SMILES has no E/Z notation to flip")
+
+        result = flip_ez(smi)
+        if result is None or result == smi:
+            raise ActionError("FlipEZ: flip produced no change or invalid molecule")
+        # Strip atom map numbers and return canonical form
+        mol_r = Chem.MolFromSmiles(result)
+        if mol_r is None:
+            raise InvalidMolError(f"FlipEZ produced invalid SMILES: {result!r}")
+        return _to_canonical(mol_r)
+
+    def _move_substituent(self, rw: Chem.RWMol, action: dict):
+        """
+        Detach `substituent` from `from_atom` and reattach it to `to_atom`.
+        Works on aromatic rings by operating in Kekulé form.
+        """
+        sub_idx  = self._resolve_atom(rw, action["substituent"])
+        from_idx = self._resolve_atom(rw, action["from_atom"])
+        to_idx   = self._resolve_atom(rw, action["to_atom"])
+
+        bond = rw.GetBondBetweenAtoms(from_idx, sub_idx)
+        if bond is None:
+            raise BondNotFoundError(
+                f"MoveSubstituent: no bond between from_atom={from_idx} and substituent={sub_idx}"
+            )
+        bond_type = bond.GetBondType()
+        # Use SINGLE for substituent attachment (aromatic bond → substituent is always single)
+        if bond_type == Chem.BondType.AROMATIC:
+            bond_type = Chem.BondType.SINGLE
+
+        if rw.GetBondBetweenAtoms(to_idx, sub_idx) is not None:
+            raise ActionError(
+                f"MoveSubstituent: bond already exists between to_atom={to_idx} and substituent={sub_idx}"
+            )
+
+        rw = _kekulize_rw(rw)
+        rw.RemoveBond(from_idx, sub_idx)
+        # Reset explicit Hs on both endpoints so valence is recomputed by sanitize
+        for i in (from_idx, to_idx):
+            _reset_atom_hs(rw.GetAtomWithIdx(i))
+        rw.AddBond(to_idx, sub_idx, bond_type)
+        _sanitize(rw, "MoveSubstituent")
+        return rw
+
+    def _swap_substituents(self, rw: Chem.RWMol, action: dict):
+        """
+        Swap all non-ring substituents between two atoms (typically ring atoms).
+        Works on aromatic rings by operating in Kekulé form.
+        """
+        idx1 = self._resolve_atom(rw, action["atom1"])
+        idx2 = self._resolve_atom(rw, action["atom2"])
+
+        if idx1 == idx2:
+            raise ActionError("SwapSubstituents: atom1 and atom2 are the same atom")
+
+        shared_ring_atoms = set()
+        for ring in _shared_rings(rw, idx1, idx2):
+            shared_ring_atoms.update(ring)
+
+        def get_substituents(center, other_center):
+            subs = []
+            for nb in rw.GetAtomWithIdx(center).GetNeighbors():
+                nidx = nb.GetIdx()
+                if nidx in shared_ring_atoms and nidx != other_center:
+                    continue
+                if nidx == other_center:
+                    continue
+                subs.append((nidx, rw.GetBondBetweenAtoms(center, nidx).GetBondType()))
+            return subs
+
+        subs1 = get_substituents(idx1, idx2)
+        subs2 = get_substituents(idx2, idx1)
+
+        rw = _kekulize_rw(rw)
+
+        for sub_idx, _ in subs1:
+            rw.RemoveBond(idx1, sub_idx)
+        for sub_idx, _ in subs2:
+            rw.RemoveBond(idx2, sub_idx)
+
+        # Reset explicit Hs on swap targets so valence is recomputed
+        for center in (idx1, idx2):
+            _reset_atom_hs(rw.GetAtomWithIdx(center))
+
+        for sub_idx, btype in subs1:
+            bt = Chem.BondType.SINGLE if btype == Chem.BondType.AROMATIC else btype
+            rw.AddBond(idx2, sub_idx, bt)
+        for sub_idx, btype in subs2:
+            bt = Chem.BondType.SINGLE if btype == Chem.BondType.AROMATIC else btype
+            rw.AddBond(idx1, sub_idx, bt)
+
+        _sanitize(rw, "SwapSubstituents")
+        return rw
+
+    # ── Dispatch ─────────────────────────────────────────────────────────────
+
+    _SMILES_LEVEL = {"FlipEZ", "Batch"}
+
+    def _dispatch(self, smiles: str, action: dict) -> str:
+        atype = action.get("type")
+        if not atype:
+            raise UnknownActionError("Action dict missing 'type' key")
+
+        # Batch: apply actions sequentially at SMILES level
+        if atype == "Batch":
+            for sub in action["actions"]:
+                smiles = self.execute(smiles, sub)
+            return smiles
+
+        # FlipEZ: SMILES-level operation
+        if atype == "FlipEZ":
+            return self._flip_ez(smiles, action)
+
+        # All other ops: work on RWMol
+        mol = Chem.MolFromSmiles(smiles)
+        if mol is None:
+            raise InvalidMolError(f"Cannot parse SMILES: {smiles!r}")
+        rw = Chem.RWMol(copy.deepcopy(mol))
+
+        handlers = {
+            "ChangeAtom":        self._change_atom,
+            "AddAtom":           self._add_atom,
+            "RemoveAtom":        self._remove_atom,
+            "ChangeBond":        self._change_bond,
+            "AddBond":           self._add_bond,
+            "RemoveBond":        self._remove_bond,
+            "AddGroup":          self._add_group,
+            "RemoveGroup":       self._remove_group,
+            "FlipChirality":     self._flip_chirality,
+            "MoveSubstituent":   self._move_substituent,
+            "SwapSubstituents":  self._swap_substituents,
+        }
+
+        handler = handlers.get(atype)
+        if handler is None:
+            raise UnknownActionError(
+                f"Unknown action type: {atype!r}. "
+                f"Valid types: {sorted(handlers) + ['FlipEZ', 'Batch']}"
+            )
+
+        result_rw = handler(rw, action)
+        return _to_canonical(result_rw)
+
+    # ── Public API ────────────────────────────────────────────────────────────
+
+    def execute(self, smiles: str, action: dict) -> str:
+        """
+        Apply a single Action to smiles.
+
+        Args:
+            smiles: input SMILES string (with or without atom map numbers)
+            action: Action dict with 'type' key and type-specific fields
+
+        Returns:
+            Canonical SMILES after applying the action.
+
+        Raises:
+            AtomNotFoundError, BondNotFoundError, InvalidMolError, UnknownActionError
+        """
+        return self._dispatch(smiles, action)
+
+    def execute_batch(self, smiles: str, actions: list) -> str:
+        """
+        Apply a list of Actions sequentially.
+
+        Equivalent to: execute(smiles, {"type": "Batch", "actions": actions})
+        """
+        return self._dispatch(smiles, {"type": "Batch", "actions": actions})
+
+
+# ---------------------------------------------------------------------------
+# Inline tests
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    ex = ActionExecutor()
+    passed = failed = 0
+
+    def test(name, smiles, action, expected):
+        global passed, failed
+        try:
+            result = ex.execute(smiles, action)
+            exp_canon = Chem.MolToSmiles(Chem.MolFromSmiles(expected))
+            if result == exp_canon:
+                print(f"  PASS  {name}")
+                passed += 1
+            else:
+                print(f"  FAIL  {name}")
+                print(f"        input:    {smiles}")
+                print(f"        expected: {exp_canon}")
+                print(f"        got:      {result}")
+                failed += 1
+        except Exception as e:
+            print(f"  ERROR {name}: {e}")
+            failed += 1
+
+    print("=" * 60)
+    print("ActionExecutor — inline tests")
+    print("=" * 60)
+
+    # 1. ChangeAtom — element
+    test("ChangeAtom/element",
+         "CCCO",
+         {"type": "ChangeAtom", "atom": {"idx": 2}, "element": "N"},
+         "CCNO")
+
+    # 2. ChangeAtom — charge
+    test("ChangeAtom/charge",
+         "CC(=O)[O-]",
+         {"type": "ChangeAtom", "atom": {"smarts": "[O-]"}, "charge": 0},
+         "CC([O])=O")  # canonical RDKit form of acetic acid
+
+    # 3. AddAtom — via idx
+    try:
+        r = ex.execute("CCO", {"type": "AddAtom", "anchor": {"idx": 1}, "element": "C"})
+        assert Chem.MolFromSmiles(r) is not None
+        print("  PASS  AddAtom")
+        passed += 1
+    except Exception as e:
+        print(f"  FAIL  AddAtom: {e}")
+        failed += 1
+
+    # 4. RemoveAtom — via smarts
+    test("RemoveAtom",
+         "CCO",
+         {"type": "RemoveAtom", "atom": {"smarts": "[OH]"}},
+         "CC")
+
+    # 5. ChangeBond — DOUBLE→SINGLE (C=O → C-O in acetaldehyde)
+    test("ChangeBond",
+         "CC=O",
+         {"type": "ChangeBond",
+          "bond": {"atom1": {"idx": 1}, "atom2": {"idx": 2}},
+          "order": "SINGLE"},
+         "CCO")
+
+    # 6. AddBond
+    test("AddBond",
+         "CCCC",
+         {"type": "AddBond",
+          "bond": {"atom1": {"idx": 0}, "atom2": {"idx": 3}},
+          "order": "SINGLE"},
+         "C1CCC1")
+
+    # 7. RemoveBond
+    test("RemoveBond",
+         "C1CCC1",
+         {"type": "RemoveBond",
+          "bond": {"atom1": {"smarts": "[CH2]", "match_idx": 0},
+                   "atom2": {"smarts": "[CH2]", "match_idx": 3}}},
+         "CCCC")
+
+    # 8. AddGroup
+    test("AddGroup",
+         "c1ccccc1",
+         {"type": "AddGroup", "anchor": {"idx": 0}, "group": "OH"},
+         "Oc1ccccc1")
+
+    # 9. RemoveGroup
+    test("RemoveGroup",
+         "Oc1ccccc1",
+         {"type": "RemoveGroup", "anchor": {"smarts": "[c;r6]", "match_idx": 0}, "group": "OH"},
+         "c1ccccc1")
+
+    # 10. FlipChirality — via smarts
+    test("FlipChirality",
+         "C[C@@H](O)F",
+         {"type": "FlipChirality", "atom": {"smarts": "[C@@H]"}},
+         "C[C@H](O)F")
+
+    # 11. FlipEZ
+    test("FlipEZ",
+         "C/C=C/C",
+         {"type": "FlipEZ",
+          "bond": {"atom1": {"idx": 1}, "atom2": {"idx": 2}}},
+         "C/C=C\\C")
+
+    # 12. MoveSubstituent — move Cl from position 1 to position 3 on pyridine
+    # pyridine with Cl at C2: Clc1ccccn1 → move Cl to C4: c1cc(Cl)ccn1
+    test("MoveSubstituent",
+         "Clc1ccccn1",
+         {"type": "MoveSubstituent",
+          "substituent": {"smarts": "[Cl]"},
+          "from_atom":   {"smarts": "[c;r6]", "match_idx": 0},
+          "to_atom":     {"smarts": "[c;r6]", "match_idx": 2}},
+         "c1cc(Cl)ccn1")
+
+    # 13. SwapSubstituents — on o-chlorotoluene, swap Cl and CH3
+    # Cc1ccccc1Cl → Clc1ccccc1C  (same thing, test canonical form)
+    try:
+        mol_in  = Chem.MolFromSmiles("Cc1ccccc1Cl")
+        # assign map nums for stable ref
+        rw = Chem.RWMol(mol_in)
+        for a in rw.GetAtoms():
+            a.SetAtomMapNum(a.GetIdx() + 1)
+        mapped = Chem.MolToSmiles(rw)
+
+        # find the two substituted ring carbons
+        c_idx = next(a.GetIdx() for a in rw.GetAtoms()
+                     if a.GetAtomicNum() == 6 and not a.GetIsAromatic()
+                     and any(nb.GetIsAromatic() for nb in a.GetNeighbors()))
+        cl_nb = next(a for a in rw.GetAtoms() if a.GetAtomicNum() == 17)
+        cl_ring = next(nb.GetIdx() for nb in cl_nb.GetNeighbors())
+        ch3_ring = next(nb.GetIdx() for nb in rw.GetAtomWithIdx(c_idx).GetNeighbors()
+                        if nb.GetIsAromatic())
+
+        r = ex.execute(mapped, {
+            "type": "SwapSubstituents",
+            "atom1": {"map_num": ch3_ring + 1},
+            "atom2": {"map_num": cl_ring  + 1},
+        })
+        mol_r = Chem.MolFromSmiles(r)
+        assert mol_r is not None
+        print(f"  PASS  SwapSubstituents  ({Chem.MolToSmiles(mol_in)} → {r})")
+        passed += 1
+    except Exception as e:
+        print(f"  FAIL  SwapSubstituents: {e}")
+        failed += 1
+
+    # 14. Batch — two actions
+    test("Batch",
+         "CCO",
+         {"type": "Batch", "actions": [
+             {"type": "ChangeAtom", "atom": {"idx": 2}, "element": "N"},
+             {"type": "AddGroup",   "anchor": {"idx": 2}, "group": "CH3"},
+         ]},
+         "CCN(C)")
+
+    # 15. map_num AtomRef (with pre-mapped SMILES)
+    test("AtomRef/map_num",
+         "[CH3:1][CH2:2][OH:3]",
+         {"type": "ChangeAtom", "atom": {"map_num": 3}, "element": "N"},
+         "CCN")
+
+    print("=" * 60)
+    print(f"Results: {passed} passed, {failed} failed out of {passed+failed} tests")
+    print("=" * 60)

code/benchmark_eval.py

@@ -0,0 +1,400 @@
+"""
+Benchmark evaluator for MolEdit dataset.
+
+Sends (wrong_smiles_mapped + correct_image) to a vision LLM, asks it to predict
+the correction action in ActionExecutor JSON format, then verifies execution.
+
+Usage:
+    # Dry run — prints prompt for first sample, no API call
+    python benchmark_eval.py --dataset ./data/pubchem_dataset --dry_run
+
+    # Real run
+    python benchmark_eval.py \\
+        --dataset ./data/pubchem_dataset \\
+        --model gpt-4o \\
+        --api_key sk-... \\
+        --api_base https://api.openai.com/v1 \\
+        --out ./data/pubchem_dataset/benchmark_results.json \\
+        --n 20
+
+    # Filter to one op type
+    python benchmark_eval.py ... --op change_atom_element
+"""
+
+import os, sys, json, re, time, base64, argparse, random, threading
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+sys.path.insert(0, os.path.dirname(__file__))
+
+from rdkit import Chem, RDLogger
+RDLogger.DisableLog("rdApp.*")
+
+from action_executor import ActionExecutor, ActionError
+
+# ---------------------------------------------------------------------------
+# Op type name mapping: dataset format → ActionExecutor type
+# ---------------------------------------------------------------------------
+
+OLD_TO_NEW_TYPE = {
+    "change_atom_element":     "ChangeAtom",
+    "change_charge":           "ChangeAtom",
+    "add_atom":                "AddAtom",
+    "remove_atom":             "RemoveAtom",
+    "change_bond_order":       "ChangeBond",
+    "add_bond":                "AddBond",
+    "remove_bond":             "RemoveBond",
+    "add_functional_group":    "AddGroup",
+    "remove_functional_group": "RemoveGroup",
+    "flip_chirality":          "FlipChirality",
+    "flip_ez":                 "FlipEZ",
+    "move_substituent":        "MoveSubstituent",
+    "swap_substituents":       "SwapSubstituents",
+}
+
+# ---------------------------------------------------------------------------
+# System prompt
+# ---------------------------------------------------------------------------
+
+SYSTEM_PROMPT = """You are a molecular structure correction assistant.
+
+You will be shown:
+  1. An image of the CORRECT molecule
+  2. A SMILES string with atom map numbers (:[n] tags) representing the WRONG molecule
+
+Your task: identify what is wrong and output a single JSON action that corrects the wrong SMILES to match the image.
+
+## Action types and schemas
+
+  ChangeAtom:       {"type": "ChangeAtom",  "atom": AtomRef, "element": str, "charge": int}
+  AddAtom:          {"type": "AddAtom",     "anchor": AtomRef, "element": str, "bond_order": str}
+  RemoveAtom:       {"type": "RemoveAtom",  "atom": AtomRef}
+  ChangeBond:       {"type": "ChangeBond",  "bond": BondRef, "order": str}
+  AddBond:          {"type": "AddBond",     "bond": BondRef, "order": str}
+  RemoveBond:       {"type": "RemoveBond",  "bond": BondRef}
+  AddGroup:         {"type": "AddGroup",    "anchor": AtomRef, "group": str}
+  RemoveGroup:      {"type": "RemoveGroup", "anchor": AtomRef, "group": str}
+  FlipChirality:    {"type": "FlipChirality", "atom": AtomRef}
+  FlipEZ:           {"type": "FlipEZ"}
+  MoveSubstituent:  {"type": "MoveSubstituent", "substituent": AtomRef, "from_atom": AtomRef, "to_atom": AtomRef}
+  SwapSubstituents: {"type": "SwapSubstituents", "atom1": AtomRef, "atom2": AtomRef}
+
+## AtomRef and BondRef
+
+  AtomRef:  {"map_num": <integer>}   ← the number after : in the SMILES, e.g. :5 → map_num 5
+  BondRef:  {"atom1": AtomRef, "atom2": AtomRef}
+
+## Valid values
+
+  bond_order: "SINGLE" | "DOUBLE" | "TRIPLE"
+  group:      "OH" | "NH2" | "F" | "Cl" | "Br" | "CH3" | "COOH" | "CHO" | "NO2"
+  element:    standard element symbol, e.g. "C", "N", "O", "S", "F", "Cl", "Br"
+
+## Output format
+
+Output ONLY a valid JSON object with no additional text or explanation.
+Example: {"type": "ChangeAtom", "atom": {"map_num": 3}, "element": "N"}
+"""
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _img_to_b64(path):
+    with open(path, "rb") as f:
+        return base64.b64encode(f.read()).decode()
+
+
+def _extract_json(raw: str):
+    """Parse JSON from LLM output, handling markdown fences."""
+    raw = raw.strip()
+    # Try direct parse first
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError:
+        pass
+    # Strip markdown fences
+    m = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", raw, re.DOTALL)
+    if m:
+        try:
+            return json.loads(m.group(1))
+        except json.JSONDecodeError:
+            pass
+    # Find first {...} block
+    m = re.search(r"\{.*\}", raw, re.DOTALL)
+    if m:
+        try:
+            return json.loads(m.group(0))
+        except json.JSONDecodeError:
+            pass
+    return None
+
+
+def _canon(smiles):
+    if smiles is None:
+        return None
+    mol = Chem.MolFromSmiles(smiles)
+    return Chem.MolToSmiles(mol) if mol else None
+
+
+# ---------------------------------------------------------------------------
+# BenchmarkEvaluator
+# ---------------------------------------------------------------------------
+
+class BenchmarkEvaluator:
+    def __init__(self, model, api_key, api_base, dataset_dir, delay=0.5, workers=4):
+        self.model       = model
+        self.dataset_dir = dataset_dir
+        self.delay       = delay
+        self.workers     = workers
+        self.executor    = ActionExecutor()
+        self._lock       = threading.Lock()
+
+        if api_key and model:
+            import openai
+            self.client = openai.OpenAI(api_key=api_key, base_url=api_base)
+        else:
+            self.client = None
+
+    # ── Data loading ─────────────────────────────────────────────────────────
+
+    def _load_dataset(self, n=None, op_filter=None, seed=0):
+        for fname in ("dataset.json", "roundtrip_test.json"):
+            p = os.path.join(self.dataset_dir, fname)
+            if os.path.exists(p):
+                with open(p) as f:
+                    records = json.load(f)
+                break
+        else:
+            raise FileNotFoundError(f"No dataset JSON in {self.dataset_dir}")
+
+        if op_filter:
+            records = [r for r in records if r["operation"]["type"] == op_filter]
+
+        if n and n < len(records):
+            random.seed(seed)
+            records = random.sample(records, n)
+
+        return records
+
+    # ── LLM call ─────────────────────────────────────────────────────────────
+
+    def _call_llm(self, record):
+        img_path = os.path.join(self.dataset_dir, record["image_path"])
+        b64      = _img_to_b64(img_path)
+
+        messages = [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": f"Wrong SMILES (with atom map numbers): {record['wrong_smiles_mapped']}\n\nThe image below shows the CORRECT molecule. Output the JSON action to fix the wrong SMILES.",
+                    },
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:image/png;base64,{b64}"},
+                    },
+                ],
+            },
+        ]
+
+        resp = self.client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+            max_tokens=4096,
+            temperature=0,
+        )
+        return resp.choices[0].message.content
+
+    # ── Evaluate one record ───────────────────────────────────────────────────
+
+    def _evaluate_one(self, record, raw_output):
+        op_type    = record["operation"]["type"]
+        gt_ae_type = OLD_TO_NEW_TYPE.get(op_type, op_type)
+        result = {
+            "id":                record.get("id"),
+            "op_type":           op_type,
+            "image_path":        record.get("image_path"),
+            "wrong_smiles_mapped": record["wrong_smiles_mapped"],
+            "correct_smiles":    record["correct_smiles"],
+            "predicted_raw":     raw_output,
+            "predicted_action":  None,
+            "restored_smiles":   None,
+            "exec_match":        False,
+            "type_match":        False,
+            "parse_error":       False,
+            "exec_error":        None,
+        }
+
+        # 1. Parse
+        action = _extract_json(raw_output)
+        if action is None:
+            result["parse_error"] = True
+            return result
+        result["predicted_action"] = action
+
+        # 2. Type match
+        result["type_match"] = (action.get("type") == gt_ae_type)
+
+        # 3. Execute
+        try:
+            restored = self.executor.execute(record["wrong_smiles_mapped"], action)
+            result["restored_smiles"] = restored
+        except ActionError as e:
+            result["exec_error"] = str(e)
+            return result
+        except Exception as e:
+            result["exec_error"] = f"unexpected: {e}"
+            return result
+
+        # 4. Compare (canonical)
+        result["exec_match"] = (_canon(restored) == _canon(record["correct_smiles"]))
+        return result
+
+    # ── Report ────────────────────────────────────────────────────────────────
+
+    def _report(self, results, out_path=None):
+        by_op = defaultdict(list)
+        for r in results:
+            by_op[r["op_type"]].append(r)
+
+        total = len(results)
+        total_exec = sum(1 for r in results if r["exec_match"])
+        total_type = sum(1 for r in results if r["type_match"])
+        total_parse = sum(1 for r in results if r["parse_error"])
+        total_err   = sum(1 for r in results if r["exec_error"])
+
+        w = 78
+        print("=" * w)
+        print(f"  Model: {self.model or 'dry_run'}   N={total}")
+        print("=" * w)
+        print(f"{'Op Type':<32} {'N':>4}  {'ExecMatch':>10}  {'TypeMatch':>10}  {'ParseErr':>8}  {'ExecErr':>7}")
+        print("-" * w)
+
+        for op in sorted(by_op):
+            recs   = by_op[op]
+            n      = len(recs)
+            em     = sum(1 for r in recs if r["exec_match"])
+            tm     = sum(1 for r in recs if r["type_match"])
+            pe     = sum(1 for r in recs if r["parse_error"])
+            ee     = sum(1 for r in recs if r["exec_error"])
+            mark   = "" if em == n else " ✗"
+            print(f"{op:<32} {n:>4}  {em:>4}/{n:<4}{em/n*100:>4.0f}%  "
+                  f"{tm:>4}/{n:<4}{tm/n*100:>4.0f}%  {pe:>8}  {ee:>7}{mark}")
+
+        print("-" * w)
+        print(f"{'TOTAL':<32} {total:>4}  {total_exec:>4}/{total:<4}{total_exec/total*100:>4.0f}%  "
+              f"{total_type:>4}/{total:<4}{total_type/total*100:>4.0f}%  "
+              f"{total_parse:>8}  {total_err:>7}")
+        print("=" * w)
+        if out_path:
+            print(f"Results → {out_path}")
+
+    # ── Main evaluate loop ────────────────────────────────────────────────────
+
+    def evaluate(self, n=None, op_filter=None, out_path=None, seed=0):
+        records = self._load_dataset(n=n, op_filter=op_filter, seed=seed)
+        print(f"Loaded {len(records)} records from {self.dataset_dir}")
+
+        # Resume: load existing results
+        done_ids = set()
+        results  = []
+        if out_path and os.path.exists(out_path):
+            with open(out_path) as f:
+                results = json.load(f)
+            done_ids = {r["id"] for r in results}
+            print(f"Resuming: {len(done_ids)} already evaluated")
+
+        todo = [r for r in records if r.get("id") not in done_ids]
+        total = len(records)
+
+        def _process(record):
+            raw = self._call_llm(record)
+            if self.delay > 0:
+                time.sleep(self.delay)
+            return self._evaluate_one(record, raw)
+
+        completed = len(done_ids)
+        with ThreadPoolExecutor(max_workers=self.workers) as pool:
+            futures = {pool.submit(_process, r): r for r in todo}
+            for fut in as_completed(futures):
+                result = fut.result()
+                status = "✓" if result["exec_match"] else ("?" if result["parse_error"] else "✗")
+                with self._lock:
+                    results.append(result)
+                    completed += 1
+                    print(f"  [{completed}/{total}] id={result['id']} op={result['op_type']} {status}", flush=True)
+                    if out_path:
+                        with open(out_path, "w") as f:
+                            json.dump(results, f, indent=2)
+
+        self._report(results, out_path)
+        return results
+
+    def dry_run(self, op_filter=None):
+        """Print the prompt for the first matching record, no API call."""
+        records = self._load_dataset(n=None, op_filter=op_filter)
+        if not records:
+            print("No records found.")
+            return
+        r = records[0]
+        img_path = os.path.join(self.dataset_dir, r["image_path"])
+        print("=" * 60)
+        print("SYSTEM PROMPT:")
+        print("=" * 60)
+        print(SYSTEM_PROMPT)
+        print("=" * 60)
+        print("USER MESSAGE:")
+        print("=" * 60)
+        print(f"Wrong SMILES (mapped): {r['wrong_smiles_mapped']}")
+        print(f"[image: {img_path}  ({os.path.getsize(img_path)//1024} KB)]")
+        print()
+        print(f"GT operation: {r['operation']}")
+        print(f"GT correct:   {r['correct_smiles']}")
+        print("=" * 60)
+        print("Image exists:", os.path.exists(img_path))
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(description="MolEdit benchmark evaluator")
+    parser.add_argument("--dataset",  default="./data/pubchem_dataset")
+    parser.add_argument("--model",    default=None,  help="e.g. gpt-4o")
+    parser.add_argument("--api_base", default="https://api.openai.com/v1")
+    parser.add_argument("--out",      default=None,  help="Output JSON path")
+    parser.add_argument("--n",        type=int, default=None, help="Sample size")
+    parser.add_argument("--op",       default=None, help="Filter to one op type")
+    parser.add_argument("--delay",    type=float, default=0.5, help="Seconds between API calls")
+    parser.add_argument("--workers",  type=int, default=4, help="Concurrent API workers")
+    parser.add_argument("--seed",     type=int, default=0)
+    parser.add_argument("--dry_run",  action="store_true", help="Print prompt, no API call")
+    args = parser.parse_args()
+
+    api_key = os.environ.get("OPENAI_API_KEY")
+
+    ev = BenchmarkEvaluator(
+        model=args.model,
+        api_key=api_key,
+        api_base=args.api_base,
+        dataset_dir=args.dataset,
+        delay=args.delay,
+        workers=args.workers,
+    )
+
+    if args.dry_run:
+        ev.dry_run(op_filter=args.op)
+        return
+
+    if not args.model or not api_key:
+        parser.error("--model is required and OPENAI_API_KEY env var must be set (or use --dry_run)")
+
+    out = args.out or os.path.join(args.dataset, "benchmark_results.json")
+    ev.evaluate(n=args.n, op_filter=args.op, out_path=out, seed=args.seed)
+
+
+if __name__ == "__main__":
+    main()

code/build_dataset_v2.py

@@ -0,0 +1,187 @@
+"""
+Build MolEdit dataset v2 — balanced, 20 samples per op type (13 types = 260 total).
+
+Changes from v1:
+  - target_per_op is a fixed CLI arg (default 20), not derived from n_samples
+  - Uses a much larger candidate pool to handle rare op types
+  - Multi-pass: exhausts full pool before giving up on any op type
+  - Saves to a new output directory (default: ./data/pubchem_dataset_v2)
+
+Usage:
+    python build_dataset_v2.py \
+        --input  /home/dataset-assist-0/usr/lh/mzm/data/pubchem/CID-SMILES.gz.1 \
+        --output ./data/pubchem_dataset_v2 \
+        --target_per_op 20 \
+        --pool   20000 \
+        --seed   42
+"""
+
+import os, sys, json, random, argparse, subprocess, signal
+sys.path.insert(0, os.path.dirname(__file__))
+
+from rdkit import Chem
+from rdkit.Chem import Draw, AllChem
+from rdkit import RDLogger
+RDLogger.DisableLog("rdApp.*")
+
+from mol_corrupt import corrupt_molecule, CORRUPTION_TYPES
+
+
+# ---------------------------------------------------------------------------
+# Molecule filtering
+# ---------------------------------------------------------------------------
+
+def is_valid(mol, smiles):
+    if mol is None or "." in smiles:
+        return False
+    n = mol.GetNumAtoms()
+    if n < 5 or n > 60:
+        return False
+    if not any(a.GetAtomicNum() == 6 for a in mol.GetAtoms()):
+        return False
+    return True
+
+
+# ---------------------------------------------------------------------------
+# Streaming sample from gzip file
+# ---------------------------------------------------------------------------
+
+def stream_sample(filepath, pool_size, seed=42):
+    rng = random.Random(seed)
+    pool = []
+    proc = subprocess.Popen(
+        ["zcat", filepath],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.DEVNULL,
+        preexec_fn=lambda: signal.signal(signal.SIGPIPE, signal.SIG_DFL),
+    )
+    for raw in proc.stdout:
+        line = raw.decode("ascii", errors="ignore").strip()
+        parts = line.split("\t")
+        if len(parts) >= 2 and parts[0].isdigit():
+            pool.append((parts[0], parts[1]))
+        if len(pool) >= pool_size:
+            break
+    proc.kill(); proc.wait()
+    rng.shuffle(pool)
+    return pool
+
+
+def render(smiles, path, size=(400, 300)):
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return False
+    AllChem.Compute2DCoords(mol)
+    Draw.MolToFile(mol, path, size=size)
+    return True
+
+
+# ---------------------------------------------------------------------------
+# Main builder
+# ---------------------------------------------------------------------------
+
+def build(input_path, output_dir, target_per_op=20, pool_size=20000, seed=42):
+    img_dir = os.path.join(output_dir, "images")
+    os.makedirs(img_dir, exist_ok=True)
+
+    print(f"Sampling {pool_size} candidates from {input_path} ...")
+    raw_pool = stream_sample(input_path, pool_size, seed=seed)
+    print(f"  Got {len(raw_pool)} candidates, filtering ...")
+
+    valid = []
+    for cid, smi in raw_pool:
+        mol = Chem.MolFromSmiles(smi)
+        if is_valid(mol, smi):
+            valid.append((cid, Chem.MolToSmiles(mol), mol))
+    print(f"  {len(valid)} molecules passed filtering")
+
+    collected = {op: 0 for op in CORRUPTION_TYPES}
+    records = []
+    idx = 0
+    skipped = 0
+
+    # Pass through the pool repeatedly until all op types hit target
+    # or we've done max_passes full sweeps (to avoid infinite loop)
+    max_passes = 5
+    for pass_num in range(1, max_passes + 1):
+        remaining_ops = [op for op in CORRUPTION_TYPES if collected[op] < target_per_op]
+        if not remaining_ops:
+            break
+        print(f"\nPass {pass_num}: {len(remaining_ops)} op types still need samples")
+
+        random.seed(seed + pass_num)
+        random.shuffle(valid)
+
+        for cid, canonical, mol in valid:
+            if not remaining_ops:
+                break
+
+            for op_type in list(remaining_ops):
+                if collected[op_type] >= target_per_op:
+                    remaining_ops.remove(op_type)
+                    continue
+
+                result = corrupt_molecule(canonical, op_type=op_type, max_retries=15)
+                if result is None:
+                    skipped += 1
+                    continue
+
+                wrong_smi, wrong_smi_mapped, correction = result
+                item_id = f"{idx:06d}"
+                img_rel = os.path.join("images", f"{item_id}.png")
+                abs_img = os.path.join(output_dir, img_rel)
+
+                if not render(canonical, abs_img):
+                    skipped += 1
+                    continue
+
+                records.append({
+                    "id":                  item_id,
+                    "cid":                 cid,
+                    "correct_smiles":      canonical,
+                    "wrong_smiles":        wrong_smi,
+                    "wrong_smiles_mapped": wrong_smi_mapped,
+                    "image_path":          img_rel,
+                    "operation":           correction,
+                })
+                collected[op_type] += 1
+                idx += 1
+
+                if idx % 50 == 0:
+                    print(f"  {idx} samples collected ...")
+
+        remaining_ops = [op for op in CORRUPTION_TYPES if collected[op] < target_per_op]
+
+    print("\nOp type coverage:")
+    for op in CORRUPTION_TYPES:
+        mark = "✓" if collected[op] >= target_per_op else f"✗ (only {collected[op]})"
+        print(f"  {op:<35} {collected[op]:>4}  {mark}")
+
+    json_path = os.path.join(output_dir, "dataset.json")
+    with open(json_path, "w") as f:
+        json.dump(records, f, indent=2, ensure_ascii=False)
+
+    print(f"\nDone: {len(records)} samples → {json_path}  (skipped {skipped})")
+    return records
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input",         default="/home/dataset-assist-0/usr/lh/mzm/data/pubchem/CID-SMILES.gz.1")
+    parser.add_argument("--output",        default="./data/pubchem_dataset_v2")
+    parser.add_argument("--target_per_op", type=int, default=20,    help="Samples per op type")
+    parser.add_argument("--pool",          type=int, default=20000,  help="Candidate pool size from input file")
+    parser.add_argument("--seed",          type=int, default=42)
+    args = parser.parse_args()
+
+    build(
+        input_path=args.input,
+        output_dir=args.output,
+        target_per_op=args.target_per_op,
+        pool_size=args.pool,
+        seed=args.seed,
+    )

code/mol_corrupt.py

@@ -0,0 +1,544 @@
+"""
+Corruption engine using atom map numbers for stable atom identification.
+
+Each corrupt_* function returns (wrong_rw, raw_correction_with_wrong_rw_indices).
+corrupt_molecule() assigns atom map nums to wrong_rw, translates indices → map_nums,
+and returns (wrong_smiles, wrong_smiles_mapped, correction_with_maps).
+
+wrong_smiles        : clean SMILES without maps  (for display / training input)
+wrong_smiles_mapped : SMILES with :[n] map tags  (for executor to locate atoms)
+correction          : operation params use atom_map/anchor_map/atom1_map/atom2_map
+                      instead of raw atom_idx — these survive SMILES round-trips.
+"""
+
+import copy
+import random
+from rdkit import Chem
+from rdkit.Chem import AllChem
+
+from mol_ops import (
+    BOND_TYPE_MAP, BOND_TYPE_NAME, ELEM_TO_NUM, NUM_TO_ELEM,
+    FUNCTIONAL_GROUPS,
+    change_atom_element, add_atom, remove_atom, change_charge,
+    change_bond_order, add_bond, remove_bond,
+    add_functional_group, remove_functional_group,
+    flip_chirality, flip_ez,
+    validate_mol,
+)
+
+CORRUPTION_TYPES = [
+    "change_atom_element",
+    "add_atom",
+    "remove_atom",
+    "change_charge",
+    "change_bond_order",
+    "add_bond",
+    "remove_bond",
+    "add_functional_group",
+    "remove_functional_group",
+    "flip_chirality",
+    "flip_ez",
+    "move_substituent",
+    "swap_substituents",
+]
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _random_other_elem(current_elem):
+    candidates = [e for e in ("C", "N", "O", "S") if e != current_elem]
+    return random.choice(candidates)
+
+
+def _has_free_valence(atom):
+    try:
+        return atom.GetNumImplicitHs() > 0
+    except Exception:
+        return False
+
+
+def _assign_atom_maps(rw):
+    """Assign map_num = idx+1 to every atom in rw (in-place)."""
+    for atom in rw.GetAtoms():
+        atom.SetAtomMapNum(atom.GetIdx() + 1)
+
+
+def _strip_atom_maps(rw):
+    """Return a copy of rw with all atom maps removed."""
+    c = copy.deepcopy(rw)
+    for atom in c.GetAtoms():
+        atom.SetAtomMapNum(0)
+    return c
+
+
+def _translate_correction(wrong_rw, raw):
+    """
+    Translate a raw correction (atom_idx → map_num) for stable cross-SMILES use.
+    raw = {'type': ..., 'params': {atom_idx: X, ...}, 'description': ...}
+    Returns new correction dict with map_num-based params.
+    """
+    params = {}
+    for k, v in raw["params"].items():
+        if k == "atom_idx":
+            params["atom_map"] = wrong_rw.GetAtomWithIdx(v).GetAtomMapNum()
+        elif k == "anchor_idx":
+            params["anchor_map"] = wrong_rw.GetAtomWithIdx(v).GetAtomMapNum()
+        elif k == "atom_idx1":
+            params["atom1_map"] = wrong_rw.GetAtomWithIdx(v).GetAtomMapNum()
+        elif k == "atom_idx2":
+            params["atom2_map"] = wrong_rw.GetAtomWithIdx(v).GetAtomMapNum()
+        elif k == "substituent_idx":
+            params["substituent_map"] = wrong_rw.GetAtomWithIdx(v).GetAtomMapNum()
+        elif k == "from_idx":
+            params["from_map"] = wrong_rw.GetAtomWithIdx(v).GetAtomMapNum()
+        elif k == "to_idx":
+            params["to_map"] = wrong_rw.GetAtomWithIdx(v).GetAtomMapNum()
+        elif k == "ring_idx1":
+            params["ring1_map"] = wrong_rw.GetAtomWithIdx(v).GetAtomMapNum()
+        elif k == "ring_idx2":
+            params["ring2_map"] = wrong_rw.GetAtomWithIdx(v).GetAtomMapNum()
+        else:
+            params[k] = v
+    return {"type": raw["type"], "params": params, "description": raw["description"]}
+
+
+# ---------------------------------------------------------------------------
+# Individual corruption functions
+# Each returns (wrong_rw, raw_correction) or None
+# raw_correction uses atom indices in wrong_rw space
+# ---------------------------------------------------------------------------
+
+def corrupt_change_atom_element(mol):
+    rw = Chem.RWMol(mol)
+    atoms = [a for a in rw.GetAtoms()
+             if a.GetAtomicNum() > 1 and not a.GetIsAromatic()]
+    if not atoms:
+        return None
+    atom = random.choice(atoms)
+    idx = atom.GetIdx()
+    old_elem = NUM_TO_ELEM.get(atom.GetAtomicNum(), "C")
+    new_elem = _random_other_elem(old_elem)
+    result = change_atom_element(rw, atom_idx=idx, to_elem=new_elem)
+    if result is None:
+        return None
+    return result, {
+        "type": "change_atom_element",
+        "params": {"atom_idx": idx, "from_elem": new_elem, "to_elem": old_elem},
+        "description": f"Change atom {idx} from {new_elem} back to {old_elem}",
+    }
+
+
+def corrupt_add_atom(mol):
+    rw = Chem.RWMol(mol)
+    atoms = [a for a in rw.GetAtoms() if _has_free_valence(a)]
+    if not atoms:
+        return None
+    anchor = random.choice(atoms)
+    new_elem = random.choice(["C", "N", "O"])
+    result = add_atom(rw, anchor_idx=anchor.GetIdx(), new_elem=new_elem)
+    if result is None:
+        return None
+    new_idx = result.GetNumAtoms() - 1
+    return result, {
+        "type": "remove_atom",
+        "params": {"atom_idx": new_idx, "elem": new_elem},
+        "description": f"Remove extra {new_elem} atom (added by corruption)",
+    }
+
+
+def corrupt_remove_atom(mol):
+    rw = Chem.RWMol(mol)
+    terminals = [a for a in rw.GetAtoms()
+                 if a.GetDegree() == 1 and not a.IsInRing() and a.GetAtomicNum() > 1]
+    if not terminals:
+        return None
+    atom = random.choice(terminals)
+    idx = atom.GetIdx()
+    elem = NUM_TO_ELEM.get(atom.GetAtomicNum(), "C")
+    neighbor = atom.GetNeighbors()[0]
+    anchor_idx = neighbor.GetIdx()
+    bond = rw.GetBondBetweenAtoms(idx, anchor_idx)
+    bond_type = BOND_TYPE_NAME.get(bond.GetBondType(), "SINGLE")
+
+    result = remove_atom(rw, atom_idx=idx)
+    if result is None:
+        return None
+    # Atoms after idx shift down by 1
+    adj_anchor = anchor_idx if anchor_idx < idx else anchor_idx - 1
+    return result, {
+        "type": "add_atom",
+        "params": {"anchor_idx": adj_anchor, "new_elem": elem, "bond_type": bond_type},
+        "description": f"Add missing {elem} atom back to anchor",
+    }
+
+
+def corrupt_change_charge(mol):
+    rw = Chem.RWMol(mol)
+    # Only corrupt atoms that currently have charge 0 (reversible: 0→±1, then ±1→0 is safe)
+    candidates = [a for a in rw.GetAtoms()
+                  if a.GetAtomicNum() in (7, 8) and not a.GetIsAromatic()
+                  and a.GetFormalCharge() == 0 and a.GetNumImplicitHs() == 0]
+    if not candidates:
+        return None
+    atom = random.choice(candidates)
+    idx = atom.GetIdx()
+    old_charge = 0
+    new_charge = random.choice([-1, 1])
+    result = change_charge(rw, atom_idx=idx, to_charge=new_charge)
+    if result is None:
+        return None
+    return result, {
+        "type": "change_charge",
+        "params": {"atom_idx": idx, "from_charge": new_charge, "to_charge": old_charge},
+        "description": f"Change charge at atom back from {new_charge:+d} to {old_charge:+d}",
+    }
+
+
+def corrupt_change_bond_order(mol):
+    rw = Chem.RWMol(mol)
+    bonds = [b for b in rw.GetBonds()
+             if b.GetBondType() in (Chem.BondType.SINGLE, Chem.BondType.DOUBLE)
+             and not b.GetIsAromatic()]
+    if not bonds:
+        return None
+    bond = random.choice(bonds)
+    idx1, idx2 = bond.GetBeginAtomIdx(), bond.GetEndAtomIdx()
+    old_order = BOND_TYPE_NAME[bond.GetBondType()]
+    new_order = "DOUBLE" if old_order == "SINGLE" else "SINGLE"
+    result = change_bond_order(rw, atom_idx1=idx1, atom_idx2=idx2, to_order=new_order)
+    if result is None:
+        return None
+    return result, {
+        "type": "change_bond_order",
+        "params": {"atom_idx1": idx1, "atom_idx2": idx2,
+                   "from_order": new_order, "to_order": old_order},
+        "description": f"Change bond ({idx1}-{idx2}) from {new_order} back to {old_order}",
+    }
+
+
+def corrupt_add_bond(mol):
+    rw = Chem.RWMol(mol)
+    n = rw.GetNumAtoms()
+    if n < 4:
+        return None
+    pairs = [(i, j) for i in range(n) for j in range(i + 2, n)
+             if rw.GetBondBetweenAtoms(i, j) is None]
+    if not pairs:
+        return None
+    i, j = random.choice(pairs)
+    result = add_bond(rw, atom_idx1=i, atom_idx2=j, bond_type="SINGLE")
+    if result is None:
+        return None
+    return result, {
+        "type": "remove_bond",
+        "params": {"atom_idx1": i, "atom_idx2": j},
+        "description": f"Remove spurious bond between atoms {i} and {j}",
+    }
+
+
+def corrupt_remove_bond(mol):
+    rw = Chem.RWMol(mol)
+    bonds = [b for b in rw.GetBonds() if not b.IsInRing()]
+    if not bonds:
+        return None
+    bond = random.choice(bonds)
+    idx1, idx2 = bond.GetBeginAtomIdx(), bond.GetEndAtomIdx()
+    order = BOND_TYPE_NAME.get(bond.GetBondType(), "SINGLE")
+    result = remove_bond(rw, atom_idx1=idx1, atom_idx2=idx2)
+    if result is None:
+        return None
+    return result, {
+        "type": "add_bond",
+        "params": {"atom_idx1": idx1, "atom_idx2": idx2, "bond_type": order},
+        "description": f"Add back {order} bond between atoms {idx1} and {idx2}",
+    }
+
+
+def corrupt_add_functional_group(mol):
+    rw = Chem.RWMol(mol)
+    atoms = [a for a in rw.GetAtoms() if a.GetAtomicNum() == 6]
+    if not atoms:
+        return None
+    anchor = random.choice(atoms)
+    group = random.choice(["OH", "NH2", "F", "Cl", "Br", "CH3"])
+    result = add_functional_group(rw, anchor_idx=anchor.GetIdx(), group_name=group)
+    if result is None:
+        return None
+    # anchor idx unchanged after adding group atoms at the end
+    return result, {
+        "type": "remove_functional_group",
+        "params": {"anchor_idx": anchor.GetIdx(), "group_name": group},
+        "description": f"Remove extra -{group} group",
+    }
+
+
+def corrupt_remove_functional_group(mol):
+    rw = Chem.RWMol(mol)
+    for group in ("OH", "NH2", "F", "Cl", "Br", "CH3"):
+        for atom in rw.GetAtoms():
+            if atom.GetAtomicNum() != 6:
+                continue
+            test = Chem.RWMol(mol)
+            result, removed = remove_functional_group(test, atom.GetIdx(), group)
+            if result is None:
+                continue
+            removed_idx = removed[0]
+            anchor_in_mol = atom.GetIdx()
+            # After removing atom at removed_idx, anchor shifts if removed_idx < anchor
+            adj_anchor = anchor_in_mol if removed_idx > anchor_in_mol else anchor_in_mol - 1
+            return result, {
+                "type": "add_functional_group",
+                "params": {"anchor_idx": adj_anchor, "group_name": group},
+                "description": f"Add -{group} back to anchor atom",
+            }
+    return None
+
+
+def corrupt_flip_chirality(mol):
+    rw = Chem.RWMol(mol)
+    Chem.AssignStereochemistry(rw, cleanIt=True, force=True)
+    chiral = [a for a in rw.GetAtoms()
+              if a.GetChiralTag() != Chem.ChiralType.CHI_UNSPECIFIED]
+    if not chiral:
+        return None
+    atom = random.choice(chiral)
+    idx = atom.GetIdx()
+    result = flip_chirality(rw, atom_idx=idx)
+    if result is None:
+        return None
+    return result, {
+        "type": "flip_chirality",
+        "params": {"atom_idx": idx},
+        "description": f"Flip chirality back at atom {idx}",
+    }
+
+
+def corrupt_flip_ez(mol):
+    """SMILES-level; returns (wrong_smi, raw_correction) directly."""
+    smi = Chem.MolToSmiles(mol, isomericSmiles=True)
+    if "/" not in smi and "\\" not in smi:
+        return None
+    wrong_smi = flip_ez(smi)
+    if wrong_smi is None or wrong_smi == smi:
+        return None
+    return wrong_smi, {
+        "type": "flip_ez",
+        "params": {},
+        "description": "Flip E/Z configuration back",
+    }
+
+
+def corrupt_move_substituent(mol):
+    """
+    Move a non-ring substituent from one ring atom to a different ring atom
+    in the same ring (e.g. ortho→meta shift on benzene).
+    Operates in Kekulé form to avoid aromatic bond issues.
+    Correction: MoveSubstituent back.
+    """
+    rw = Chem.RWMol(mol)
+    try:
+        Chem.Kekulize(rw, clearAromaticFlags=True)
+    except Exception:
+        return None
+
+    ri = rw.GetRingInfo()
+    rings = [set(r) for r in ri.AtomRings() if len(r) >= 5]
+    if not rings:
+        return None
+
+    # Build all (from_idx, sub_idx, to_idx) triples and shuffle
+    triples = []
+    for ring in rings:
+        ring_list = list(ring)
+        for from_idx in ring_list:
+            atom = rw.GetAtomWithIdx(from_idx)
+            subs = [nb for nb in atom.GetNeighbors()
+                    if nb.GetIdx() not in ring and nb.GetAtomicNum() > 1]
+            for sub in subs:
+                sub_idx = sub.GetIdx()
+                for to_idx in ring_list:
+                    if to_idx != from_idx and rw.GetBondBetweenAtoms(to_idx, sub_idx) is None:
+                        triples.append((from_idx, sub_idx, to_idx))
+    random.shuffle(triples)
+
+    for from_idx, sub_idx, to_idx in triples:
+        rw2 = Chem.RWMol(copy.deepcopy(rw))
+        rw2.RemoveBond(from_idx, sub_idx)
+        rw2.AddBond(to_idx, sub_idx, Chem.BondType.SINGLE)
+        if not validate_mol(rw2):
+            continue
+        # Check it actually changed the molecule
+        wrong_smi = Chem.MolToSmiles(rw2)
+        orig_smi = Chem.MolToSmiles(mol)
+        if wrong_smi == orig_smi:
+            continue
+        return rw2, {
+            "type": "move_substituent",
+            "params": {
+                "substituent_idx": sub_idx,
+                "from_idx": to_idx,    # correction reverses: from=to, to=from
+                "to_idx":   from_idx,
+            },
+            "description": f"Move substituent {sub_idx} back from ring atom {to_idx} to {from_idx}",
+        }
+    return None
+
+
+def corrupt_swap_substituents(mol):
+    """
+    Swap the non-ring substituents of two ring atoms in the same ring.
+    Operates in Kekulé form to avoid aromatic bond issues.
+    Correction: SwapSubstituents back (same action).
+    """
+    rw = Chem.RWMol(mol)
+    try:
+        Chem.Kekulize(rw, clearAromaticFlags=True)
+    except Exception:
+        return None
+
+    ri = rw.GetRingInfo()
+    rings = [list(r) for r in ri.AtomRings() if len(r) >= 5]
+    if not rings:
+        return None
+
+    random.shuffle(rings)
+    for ring in rings:
+        ring_set = set(ring)
+        substituted = []
+        for idx in ring:
+            subs = [nb.GetIdx() for nb in rw.GetAtomWithIdx(idx).GetNeighbors()
+                    if nb.GetIdx() not in ring_set and nb.GetAtomicNum() > 1]
+            if subs:
+                substituted.append((idx, subs))
+        if len(substituted) < 2:
+            continue
+
+        random.shuffle(substituted)
+        (idx1, subs1), (idx2, subs2) = substituted[0], substituted[1]
+
+        def bonds_to(center, sub_list):
+            return [(s, rw.GetBondBetweenAtoms(center, s).GetBondType()) for s in sub_list]
+
+        b1 = bonds_to(idx1, subs1)
+        b2 = bonds_to(idx2, subs2)
+
+        if any(rw.GetBondBetweenAtoms(idx2, s) is not None for s, _ in b1):
+            continue
+        if any(rw.GetBondBetweenAtoms(idx1, s) is not None for s, _ in b2):
+            continue
+
+        rw2 = Chem.RWMol(copy.deepcopy(rw))
+        for s, _ in b1:
+            rw2.RemoveBond(idx1, s)
+        for s, _ in b2:
+            rw2.RemoveBond(idx2, s)
+        for s, bt in b1:
+            rw2.AddBond(idx2, s, Chem.BondType.SINGLE)
+        for s, bt in b2:
+            rw2.AddBond(idx1, s, Chem.BondType.SINGLE)
+
+        if not validate_mol(rw2):
+            continue
+        return rw2, {
+            "type": "swap_substituents",
+            "params": {
+                "ring_idx1": idx1,
+                "ring_idx2": idx2,
+            },
+            "description": f"Swap substituents back between ring atoms {idx1} and {idx2}",
+        }
+    return None
+
+
+CORRUPT_FUNCS = {
+    "change_atom_element":     corrupt_change_atom_element,
+    "add_atom":                corrupt_add_atom,
+    "remove_atom":             corrupt_remove_atom,
+    "change_charge":           corrupt_change_charge,
+    "change_bond_order":       corrupt_change_bond_order,
+    "add_bond":                corrupt_add_bond,
+    "remove_bond":             corrupt_remove_bond,
+    "add_functional_group":    corrupt_add_functional_group,
+    "remove_functional_group": corrupt_remove_functional_group,
+    "flip_chirality":          corrupt_flip_chirality,
+    "flip_ez":                 corrupt_flip_ez,
+    "move_substituent":        corrupt_move_substituent,
+    "swap_substituents":       corrupt_swap_substituents,
+}
+
+
+# ---------------------------------------------------------------------------
+# Main API
+# ---------------------------------------------------------------------------
+
+def corrupt_molecule(smiles, op_type=None, max_retries=20):
+    """
+    Returns (wrong_smiles, wrong_smiles_mapped, correction) or None.
+
+    wrong_smiles        — clean SMILES (no atom maps), the erroneous input
+    wrong_smiles_mapped — SMILES with :[n] atom map tags for executor use
+    correction          — dict with type, params (map_num-based), description
+    """
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return None
+
+    for _ in range(max_retries):
+        chosen_type = op_type or random.choice(CORRUPTION_TYPES)
+        func = CORRUPT_FUNCS[chosen_type]
+        raw = func(mol)
+        if raw is None:
+            continue
+
+        # flip_ez is SMILES-level — handle separately
+        if chosen_type == "flip_ez":
+            wrong_smi, raw_correction = raw
+            if wrong_smi == smiles:
+                continue
+            wrong_mol = Chem.MolFromSmiles(wrong_smi)
+            if wrong_mol is None:
+                continue
+            wrong_rw = Chem.RWMol(wrong_mol)
+            _assign_atom_maps(wrong_rw)
+            wrong_smiles_mapped = Chem.MolToSmiles(wrong_rw)
+            correction = {"type": "flip_ez", "params": {},
+                          "description": raw_correction["description"]}
+            return wrong_smi, wrong_smiles_mapped, correction
+
+        wrong_rw, raw_correction = raw
+        if not validate_mol(wrong_rw):
+            continue
+
+        # Assign atom map numbers to wrong_rw (map_num = idx + 1)
+        _assign_atom_maps(wrong_rw)
+
+        # Translate index-based params → map-num-based params
+        try:
+            correction = _translate_correction(wrong_rw, raw_correction)
+        except (IndexError, RuntimeError):
+            continue
+
+        # Generate clean wrong SMILES (no maps)
+        wrong_smiles = Chem.MolToSmiles(_strip_atom_maps(wrong_rw))
+        if wrong_smiles == smiles:
+            continue
+
+        wrong_smiles_mapped = Chem.MolToSmiles(wrong_rw)
+
+        # ── Verify round-trip before accepting ──────────────────────────────
+        from action_executor import ActionExecutor as _AE
+        from validate_with_executor import translate_operation
+        try:
+            action = translate_operation(correction)
+            restored = _AE().execute(wrong_smiles_mapped, action)
+        except Exception:
+            continue
+        restored_mol = Chem.MolFromSmiles(restored) if restored else None
+        if restored_mol is None or Chem.MolToSmiles(restored_mol) != smiles:
+            continue  # bad sample — discard and retry
+
+        return wrong_smiles, wrong_smiles_mapped, correction
+
+    return None

code/mol_ops.py

@@ -0,0 +1,287 @@
+"""
+Core molecular editing operations using RDKit's RWMol API.
+
+Each operation takes an RWMol and parameters, returns the modified RWMol.
+Each has a forward (corruption) and inverse (correction) form.
+"""
+
+import copy
+from rdkit import Chem
+from rdkit.Chem import AllChem, rdmolops
+
+
+BOND_TYPE_MAP = {
+    "SINGLE": Chem.BondType.SINGLE,
+    "DOUBLE": Chem.BondType.DOUBLE,
+    "TRIPLE": Chem.BondType.TRIPLE,
+    "AROMATIC": Chem.BondType.AROMATIC,
+}
+
+BOND_TYPE_NAME = {v: k for k, v in BOND_TYPE_MAP.items()}
+
+ELEM_TO_NUM = {
+    "C": 6, "N": 7, "O": 8, "S": 16, "P": 15, "F": 9,
+    "Cl": 17, "Br": 35, "I": 53, "B": 5, "Si": 14, "Se": 34,
+}
+
+NUM_TO_ELEM = {v: k for k, v in ELEM_TO_NUM.items()}
+
+FUNCTIONAL_GROUPS = {
+    "OH":   "[OH]",
+    "NH2":  "[NH2]",
+    "F":    "[F]",
+    "Cl":   "[Cl]",
+    "Br":   "[Br]",
+    "CH3":  "[CH3]",
+    "NO2":  "[N+](=O)[O-]",
+    "COOH": "C(=O)[OH]",
+    "CHO":  "[CH]=O",
+}
+
+
+def validate_mol(mol):
+    if mol is None:
+        return False
+    try:
+        Chem.SanitizeMol(mol)
+        return True
+    except Exception:
+        return False
+
+
+def safe_apply(func):
+    """Decorator: returns None if the operation produces an invalid molecule."""
+    def wrapper(mol, **kwargs):
+        rw = copy.deepcopy(mol)
+        try:
+            result = func(rw, **kwargs)
+            if result is None:
+                return None
+            if not validate_mol(result):
+                return None
+            return result
+        except Exception:
+            return None
+    return wrapper
+
+
+# ---------------------------------------------------------------------------
+# 1. change_atom_element
+# ---------------------------------------------------------------------------
+@safe_apply
+def change_atom_element(mol, atom_idx, to_elem):
+    atom = mol.GetAtomWithIdx(atom_idx)
+    atom.SetAtomicNum(ELEM_TO_NUM[to_elem])
+    atom.SetNoImplicit(False)
+    atom.UpdatePropertyCache(strict=False)
+    return mol
+
+
+# ---------------------------------------------------------------------------
+# 2. add_atom — adds a new atom bonded to anchor
+# ---------------------------------------------------------------------------
+@safe_apply
+def add_atom(mol, anchor_idx, new_elem, bond_type="SINGLE"):
+    new_idx = mol.AddAtom(Chem.Atom(ELEM_TO_NUM[new_elem]))
+    mol.AddBond(anchor_idx, new_idx, BOND_TYPE_MAP[bond_type])
+    return mol
+
+
+# ---------------------------------------------------------------------------
+# 3. remove_atom
+# ---------------------------------------------------------------------------
+@safe_apply
+def remove_atom(mol, atom_idx):
+    mol.RemoveAtom(atom_idx)
+    return mol
+
+
+# ---------------------------------------------------------------------------
+# 4. change_charge
+# ---------------------------------------------------------------------------
+@safe_apply
+def change_charge(mol, atom_idx, to_charge):
+    atom = mol.GetAtomWithIdx(atom_idx)
+    atom.SetFormalCharge(to_charge)
+    atom.UpdatePropertyCache(strict=False)
+    return mol
+
+
+# ---------------------------------------------------------------------------
+# 5. change_bond_order
+# ---------------------------------------------------------------------------
+@safe_apply
+def change_bond_order(mol, atom_idx1, atom_idx2, to_order):
+    bond = mol.GetBondBetweenAtoms(atom_idx1, atom_idx2)
+    if bond is None:
+        return None
+    bond.SetBondType(BOND_TYPE_MAP[to_order])
+    return mol
+
+
+# ---------------------------------------------------------------------------
+# 6. add_bond
+# ---------------------------------------------------------------------------
+@safe_apply
+def add_bond(mol, atom_idx1, atom_idx2, bond_type="SINGLE"):
+    existing = mol.GetBondBetweenAtoms(atom_idx1, atom_idx2)
+    if existing is not None:
+        return None
+    mol.AddBond(atom_idx1, atom_idx2, BOND_TYPE_MAP[bond_type])
+    return mol
+
+
+# ---------------------------------------------------------------------------
+# 7. remove_bond
+# ---------------------------------------------------------------------------
+@safe_apply
+def remove_bond(mol, atom_idx1, atom_idx2):
+    bond = mol.GetBondBetweenAtoms(atom_idx1, atom_idx2)
+    if bond is None:
+        return None
+    mol.RemoveBond(atom_idx1, atom_idx2)
+    return mol
+
+
+# ---------------------------------------------------------------------------
+# 8. add_functional_group
+# ---------------------------------------------------------------------------
+@safe_apply
+def add_functional_group(mol, anchor_idx, group_name):
+    group_smi = FUNCTIONAL_GROUPS.get(group_name)
+    if group_smi is None:
+        return None
+    group_mol = Chem.MolFromSmiles(group_smi)
+    if group_mol is None:
+        return None
+
+    combo = Chem.RWMol(rdmolops.CombineMols(mol, group_mol))
+    old_n = mol.GetNumAtoms()
+    anchor = combo.GetAtomWithIdx(anchor_idx)
+    anchor.SetNumExplicitHs(0)
+    anchor.SetNoImplicit(False)
+    anchor.SetNumRadicalElectrons(0)
+    combo.AddBond(anchor_idx, old_n, Chem.BondType.SINGLE)
+    return combo
+
+
+# ---------------------------------------------------------------------------
+# 9. remove_functional_group (removes a terminal substituent at anchor)
+# ---------------------------------------------------------------------------
+def remove_functional_group(mol, anchor_idx, group_name):
+    """Remove atoms belonging to a terminal functional group attached at anchor_idx.
+    Returns (new_mol, removed_atom_indices) or (None, [])."""
+    rw = copy.deepcopy(mol)
+    anchor = rw.GetAtomWithIdx(anchor_idx)
+    neighbors = [n for n in anchor.GetNeighbors()]
+
+    if group_name in ("F", "Cl", "Br"):
+        target_num = ELEM_TO_NUM.get(group_name)
+        for n in neighbors:
+            if n.GetAtomicNum() == target_num and n.GetDegree() == 1:
+                idx = n.GetIdx()
+                rw.RemoveAtom(idx)
+                try:
+                    Chem.SanitizeMol(rw)
+                    return rw, [idx]
+                except Exception:
+                    return None, []
+        return None, []
+
+    if group_name == "OH":
+        for n in neighbors:
+            if n.GetAtomicNum() == 8 and n.GetDegree() == 1:
+                bond = rw.GetBondBetweenAtoms(anchor_idx, n.GetIdx())
+                if bond and bond.GetBondType() == Chem.BondType.SINGLE:
+                    idx = n.GetIdx()
+                    rw.RemoveAtom(idx)
+                    try:
+                        Chem.SanitizeMol(rw)
+                        return rw, [idx]
+                    except Exception:
+                        return None, []
+        return None, []
+
+    if group_name == "NH2":
+        for n in neighbors:
+            if n.GetAtomicNum() == 7 and n.GetDegree() == 1:
+                idx = n.GetIdx()
+                rw.RemoveAtom(idx)
+                try:
+                    Chem.SanitizeMol(rw)
+                    return rw, [idx]
+                except Exception:
+                    return None, []
+        return None, []
+
+    if group_name == "CH3":
+        for n in neighbors:
+            if n.GetAtomicNum() == 6 and n.GetDegree() == 1 and n.GetTotalNumHs() == 3:
+                idx = n.GetIdx()
+                rw.RemoveAtom(idx)
+                try:
+                    Chem.SanitizeMol(rw)
+                    return rw, [idx]
+                except Exception:
+                    return None, []
+        return None, []
+
+    return None, []
+
+
+# ---------------------------------------------------------------------------
+# 10. flip_chirality
+# ---------------------------------------------------------------------------
+@safe_apply
+def flip_chirality(mol, atom_idx):
+    atom = mol.GetAtomWithIdx(atom_idx)
+    chi = atom.GetChiralTag()
+    if chi == Chem.ChiralType.CHI_TETRAHEDRAL_CW:
+        atom.SetChiralTag(Chem.ChiralType.CHI_TETRAHEDRAL_CCW)
+    elif chi == Chem.ChiralType.CHI_TETRAHEDRAL_CCW:
+        atom.SetChiralTag(Chem.ChiralType.CHI_TETRAHEDRAL_CW)
+    else:
+        return None
+    return mol
+
+
+# ---------------------------------------------------------------------------
+# 11. flip_ez — flip E/Z via SMILES-level slash inversion
+# ---------------------------------------------------------------------------
+def flip_ez(smiles):
+    """Flip E/Z by inverting the first /-slash in the SMILES.
+    Works at the SMILES string level since RDKit mol-level stereo
+    doesn't round-trip reliably through MolToSmiles."""
+    if "/" not in smiles and "\\" not in smiles:
+        return None
+    chars = list(smiles)
+    for i, c in enumerate(chars):
+        if c == "/":
+            chars[i] = "\\"
+            break
+        elif c == "\\":
+            chars[i] = "/"
+            break
+    new_smi = "".join(chars)
+    mol = Chem.MolFromSmiles(new_smi)
+    if mol is None:
+        return None
+    return Chem.MolToSmiles(mol, isomericSmiles=True)
+
+
+# ---------------------------------------------------------------------------
+# Registry: maps operation type name → apply function
+# ---------------------------------------------------------------------------
+OP_REGISTRY = {
+    "change_atom_element": change_atom_element,
+    "add_atom":            add_atom,
+    "remove_atom":         remove_atom,
+    "change_charge":       change_charge,
+    "change_bond_order":   change_bond_order,
+    "add_bond":            add_bond,
+    "remove_bond":         remove_bond,
+    "add_functional_group":    add_functional_group,
+    "remove_functional_group": lambda mol, **kw: remove_functional_group(mol, **kw)[0],
+    "flip_chirality":      flip_chirality,
+    "flip_ez":             flip_ez,
+}

code/validate_with_executor.py

@@ -0,0 +1,263 @@
+"""
+Validate pubchem_dataset records using ActionExecutor.
+
+Translates old-format operation dicts (raw atom_idx params) to the new
+ActionExecutor JSON protocol, then checks that executing the action on
+wrong_smiles reproduces correct_smiles.
+
+Usage:
+    python validate_with_executor.py [--dataset ./data/pubchem_dataset] [--verbose]
+"""
+
+import os, sys, json, argparse
+from collections import Counter, defaultdict
+sys.path.insert(0, os.path.dirname(__file__))
+
+from rdkit import Chem, RDLogger
+RDLogger.DisableLog("rdApp.*")
+
+from action_executor import ActionExecutor, ActionError
+
+
+# ---------------------------------------------------------------------------
+# Old-format → ActionExecutor JSON translation
+# ---------------------------------------------------------------------------
+
+def translate_operation(op: dict) -> dict:
+    """
+    Convert a mol_corrupt.py correction dict to an ActionExecutor action dict.
+
+    New format (atom_map / anchor_map / atom1_map / atom2_map) uses map_num refs.
+    Old format (atom_idx / anchor_idx / atom_idx1 / atom_idx2) uses idx refs.
+    Both are handled transparently.
+    """
+    old_type = op["type"]
+    params   = op.get("params", {})
+
+    # Determine ref style: map-num (new) or raw idx (old)
+    has_maps = any(k in params for k in ("atom_map", "anchor_map", "atom1_map", "atom2_map"))
+
+    def atom_ref(map_key, idx_key):
+        if has_maps and map_key in params:
+            return {"map_num": params[map_key]}
+        return {"idx": params[idx_key]}
+
+    def bond_ref(map1, idx1, map2, idx2):
+        return {"atom1": atom_ref(map1, idx1), "atom2": atom_ref(map2, idx2)}
+
+    if old_type == "change_atom_element":
+        return {
+            "type":    "ChangeAtom",
+            "atom":    atom_ref("atom_map", "atom_idx"),
+            "element": params["to_elem"],
+        }
+
+    if old_type == "change_charge":
+        return {
+            "type":   "ChangeAtom",
+            "atom":   atom_ref("atom_map", "atom_idx"),
+            "charge": params["to_charge"],
+        }
+
+    if old_type == "add_atom":
+        return {
+            "type":       "AddAtom",
+            "anchor":     atom_ref("anchor_map", "anchor_idx"),
+            "element":    params["new_elem"],
+            "bond_order": params.get("bond_type", "SINGLE"),
+        }
+
+    if old_type == "remove_atom":
+        return {
+            "type": "RemoveAtom",
+            "atom": atom_ref("atom_map", "atom_idx"),
+        }
+
+    if old_type == "change_bond_order":
+        return {
+            "type":  "ChangeBond",
+            "bond":  bond_ref("atom1_map", "atom_idx1", "atom2_map", "atom_idx2"),
+            "order": params["to_order"],
+        }
+
+    if old_type == "add_bond":
+        return {
+            "type":  "AddBond",
+            "bond":  bond_ref("atom1_map", "atom_idx1", "atom2_map", "atom_idx2"),
+            "order": params.get("bond_type", "SINGLE"),
+        }
+
+    if old_type == "remove_bond":
+        return {
+            "type": "RemoveBond",
+            "bond": bond_ref("atom1_map", "atom_idx1", "atom2_map", "atom_idx2"),
+        }
+
+    if old_type == "add_functional_group":
+        return {
+            "type":   "AddGroup",
+            "anchor": atom_ref("anchor_map", "anchor_idx"),
+            "group":  params["group_name"],
+        }
+
+    if old_type == "remove_functional_group":
+        return {
+            "type":   "RemoveGroup",
+            "anchor": atom_ref("anchor_map", "anchor_idx"),
+            "group":  params["group_name"],
+        }
+
+    if old_type == "flip_chirality":
+        return {
+            "type": "FlipChirality",
+            "atom": atom_ref("atom_map", "atom_idx"),
+        }
+
+    if old_type == "flip_ez":
+        # SMILES-level op — find the double bond automatically
+        return {"type": "FlipEZ"}
+
+    if old_type == "move_substituent":
+        return {
+            "type":        "MoveSubstituent",
+            "substituent": {"map_num": params["substituent_map"]},
+            "from_atom":   {"map_num": params["from_map"]},
+            "to_atom":     {"map_num": params["to_map"]},
+        }
+
+    if old_type == "swap_substituents":
+        return {
+            "type":  "SwapSubstituents",
+            "atom1": {"map_num": params["ring1_map"]},
+            "atom2": {"map_num": params["ring2_map"]},
+        }
+
+    raise ValueError(f"Unhandled old type: {old_type!r}")
+
+
+# ---------------------------------------------------------------------------
+# Validation
+# ---------------------------------------------------------------------------
+
+def validate(records, verbose=False):
+    ex = ActionExecutor()
+    results = defaultdict(lambda: {"pass": 0, "fail": 0, "error": 0})
+    failures = []
+
+    for r in records:
+        op_type  = r["operation"]["type"]
+        # Prefer mapped SMILES (new format) so map_num refs work correctly
+        wrong    = r.get("wrong_smiles_mapped") or r.get("wrong_smiles", "")
+        correct  = r["correct_smiles"]
+
+        try:
+            action = translate_operation(r["operation"])
+        except Exception as e:
+            results[op_type]["error"] += 1
+            failures.append({"id": r.get("id"), "op": op_type, "kind": "translate_error", "msg": str(e)})
+            continue
+
+        try:
+            restored = ex.execute(wrong, action)
+        except ActionError as e:
+            results[op_type]["error"] += 1
+            failures.append({
+                "id": r.get("id"), "op": op_type, "kind": "executor_error",
+                "msg": str(e), "wrong": wrong, "action": action,
+            })
+            continue
+        except Exception as e:
+            results[op_type]["error"] += 1
+            failures.append({
+                "id": r.get("id"), "op": op_type, "kind": "unexpected_error",
+                "msg": str(e), "wrong": wrong,
+            })
+            continue
+
+        # Canonicalize both for fair comparison
+        mol_r = Chem.MolFromSmiles(restored) if restored else None
+        mol_c = Chem.MolFromSmiles(correct)
+        canon_r = Chem.MolToSmiles(mol_r) if mol_r else None
+        canon_c = Chem.MolToSmiles(mol_c) if mol_c else None
+
+        if canon_r == canon_c:
+            results[op_type]["pass"] += 1
+        else:
+            results[op_type]["fail"] += 1
+            failures.append({
+                "id": r.get("id"), "op": op_type, "kind": "mismatch",
+                "wrong": wrong, "expected": correct, "got": restored,
+                "action": action,
+            })
+
+    return results, failures
+
+
+# ---------------------------------------------------------------------------
+# Report
+# ---------------------------------------------------------------------------
+
+def report(results, failures, verbose=False):
+    print("=" * 76)
+    print(f"{'Op Type':<35} {'Total':>6} {'Pass':>5} {'Fail':>5} {'Error':>6} {'Rate':>6}")
+    print("-" * 76)
+
+    total_p = total_f = total_e = 0
+    for op in sorted(results):
+        r = results[op]
+        p, f, e = r["pass"], r["fail"], r["error"]
+        n = p + f + e
+        rate = p / n * 100 if n else 0
+        mark = "" if (f + e) == 0 else " ✗"
+        print(f"{op:<35} {n:>6} {p:>5} {f:>5} {e:>6} {rate:>5.0f}%{mark}")
+        total_p += p; total_f += f; total_e += e
+
+    total = total_p + total_f + total_e
+    print("-" * 76)
+    rate = total_p / total * 100 if total else 0
+    print(f"{'TOTAL':<35} {total:>6} {total_p:>5} {total_f:>5} {total_e:>6} {rate:>5.0f}%")
+    print("=" * 76)
+
+    if failures:
+        show = failures if verbose else failures[:5]
+        print(f"\n--- {len(failures)} failure(s){' (showing first 5)' if not verbose and len(failures) > 5 else ''} ---")
+        for fl in show:
+            print(f"\n  [{fl['op']}] id={fl.get('id')}  kind={fl['kind']}")
+            if fl["kind"] == "mismatch":
+                print(f"    wrong    : {fl['wrong']}")
+                print(f"    action   : {fl['action']}")
+                print(f"    expected : {fl['expected']}")
+                print(f"    got      : {fl['got']}")
+            elif fl["kind"] in ("executor_error", "translate_error", "unexpected_error"):
+                print(f"    wrong    : {fl.get('wrong', '')}")
+                print(f"    action   : {fl.get('action', '')}")
+                print(f"    error    : {fl['msg']}")
+    else:
+        print("\n✓ All records pass validation.")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--dataset", default="./data/pubchem_dataset")
+    parser.add_argument("--verbose", action="store_true", help="Show all failures")
+    args = parser.parse_args()
+
+    for name in ("dataset.json", "roundtrip_test.json"):
+        p = os.path.join(args.dataset, name)
+        if os.path.exists(p):
+            json_path = p
+            break
+    else:
+        print(f"No dataset JSON found in {args.dataset}")
+        sys.exit(1)
+
+    with open(json_path) as f:
+        records = json.load(f)
+    print(f"Loaded {len(records)} records from {json_path}\n")
+
+    results, failures = validate(records, verbose=args.verbose)
+    report(results, failures, verbose=args.verbose)
+
+
+if __name__ == "__main__":
+    main()

data/benchmark_results_gpt55.json

@@ -0,0 +1,1901 @@
+[
+  {
+    "id": "000005",
+    "op_type": "remove_functional_group",
+    "image_path": "images/000005.png",
+    "wrong_smiles_mapped": "[CH3:1][C:2]([CH3:3])([CH3:4])[c:5]1[cH:6][c:7]([F:13])[c:8]([OH:9])[c:10]([OH:11])[cH:12]1",
+    "correct_smiles": "CC(C)(C)c1ccc(O)c(O)c1",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":13}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 13
+      }
+    },
+    "restored_smiles": "CC(C)(C)c1ccc(O)c(O)c1",
+    "exec_match": true,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000004",
+    "op_type": "add_bond",
+    "image_path": "images/000004.png",
+    "wrong_smiles_mapped": "[CH3:1][C:2]([CH3:3])([CH3:4])[c:5]1[cH:6][cH:7][c:8]([OH:9])[cH:10][cH:12]1.[OH2:11]",
+    "correct_smiles": "CC(C)(C)c1ccc(O)c(O)c1",
+    "predicted_raw": "{\"type\":\"AddBond\",\"bond\":{\"atom1\":{\"map_num\":10},\"atom2\":{\"map_num\":11}},\"order\":\"SINGLE\"}",
+    "predicted_action": {
+      "type": "AddBond",
+      "bond": {
+        "atom1": {
+          "map_num": 10
+        },
+        "atom2": {
+          "map_num": 11
+        }
+      },
+      "order": "SINGLE"
+    },
+    "restored_smiles": "CC(C)(C)c1ccc(O)c(O)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000006",
+    "op_type": "add_functional_group",
+    "image_path": "images/000006.png",
+    "wrong_smiles_mapped": "[CH3:1][C:2]([CH3:3])([CH3:4])[c:5]1[cH:6][cH:7][cH:8][c:9]([OH:10])[cH:11]1",
+    "correct_smiles": "CC(C)(C)c1ccc(O)c(O)c1",
+    "predicted_raw": "{\"type\":\"AddGroup\",\"anchor\":{\"map_num\":8},\"group\":\"OH\"}",
+    "predicted_action": {
+      "type": "AddGroup",
+      "anchor": {
+        "map_num": 8
+      },
+      "group": "OH"
+    },
+    "restored_smiles": "CC(C)(C)c1ccc(O)c(O)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000003",
+    "op_type": "remove_bond",
+    "image_path": "images/000003.png",
+    "wrong_smiles_mapped": "[CH3:1][C:2]1([CH3:4])[CH2:3][O:9][c:8]2[cH:7][cH:6][c:5]1[cH:12][c:10]2[OH:11]",
+    "correct_smiles": "CC(C)(C)c1ccc(O)c(O)c1",
+    "predicted_raw": "{\"type\":\"RemoveBond\",\"bond\":{\"atom1\":{\"map_num\":3},\"atom2\":{\"map_num\":9}}}",
+    "predicted_action": {
+      "type": "RemoveBond",
+      "bond": {
+        "atom1": {
+          "map_num": 3
+        },
+        "atom2": {
+          "map_num": 9
+        }
+      }
+    },
+    "restored_smiles": "CC(C)(C)c1ccc(O)c(O)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000002",
+    "op_type": "add_atom",
+    "image_path": "images/000002.png",
+    "wrong_smiles_mapped": "[CH:1]([CH3:2])([CH3:3])[c:4]1[cH:5][cH:6][c:7]([OH:8])[c:9]([OH:10])[cH:11]1",
+    "correct_smiles": "CC(C)(C)c1ccc(O)c(O)c1",
+    "predicted_raw": "{\"type\":\"AddGroup\",\"anchor\":{\"map_num\":1},\"group\":\"CH3\"}",
+    "predicted_action": {
+      "type": "AddGroup",
+      "anchor": {
+        "map_num": 1
+      },
+      "group": "CH3"
+    },
+    "restored_smiles": "CC(C)(C)c1ccc(O)c(O)c1",
+    "exec_match": true,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000007",
+    "op_type": "move_substituent",
+    "image_path": "images/000007.png",
+    "wrong_smiles_mapped": "[CH3:1][C:2]([CH3:3])([CH3:4])[c:7]1[cH:6][cH:5][cH:12][c:10]([OH:11])[c:8]1[OH:9]",
+    "correct_smiles": "CC(C)(C)c1ccc(O)c(O)c1",
+    "predicted_raw": "",
+    "predicted_action": null,
+    "restored_smiles": null,
+    "exec_match": false,
+    "type_match": false,
+    "parse_error": true,
+    "exec_error": null
+  },
+  {
+    "id": "000012",
+    "op_type": "change_charge",
+    "image_path": "images/000012.png",
+    "wrong_smiles_mapped": "[NH2:1][CH:2]([CH2:3][c:4]1[cH:5][cH:6][cH:7][c:8]([OH:9])[cH:10]1)[C:11](=[OH+:12])[OH:13]",
+    "correct_smiles": "NC(Cc1cccc(O)c1)C(=O)O",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":12},\"element\":\"O\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 12
+      },
+      "element": "O",
+      "charge": 0
+    },
+    "restored_smiles": "NC(Cc1cccc(O)c1)C(=O)O",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000010",
+    "op_type": "remove_atom",
+    "image_path": "images/000010.png",
+    "wrong_smiles_mapped": "[NH2:1][CH:2]([CH2:3][c:4]1[cH:5][cH:6][cH:7][c:8]([O:9][NH2:14])[cH:10]1)[C:11](=[O:12])[OH:13]",
+    "correct_smiles": "NC(Cc1cccc(O)c1)C(=O)O",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":14}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 14
+      }
+    },
+    "restored_smiles": "NC(Cc1cccc(O)c1)C(=O)O",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000009",
+    "op_type": "change_atom_element",
+    "image_path": "images/000009.png",
+    "wrong_smiles_mapped": "[NH2:1][N:2]([CH2:3][c:4]1[cH:5][cH:6][cH:7][c:8]([OH:9])[cH:10]1)[C:11](=[O:12])[OH:13]",
+    "correct_smiles": "NC(Cc1cccc(O)c1)C(=O)O",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":2},\"element\":\"C\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 2
+      },
+      "element": "C",
+      "charge": 0
+    },
+    "restored_smiles": "NC(Cc1cccc(O)c1)C(=O)O",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000001",
+    "op_type": "remove_atom",
+    "image_path": "images/000001.png",
+    "wrong_smiles_mapped": "[CH3:1][C:2]([CH3:3])([CH3:4])[c:5]1[cH:6][cH:7][c:8]([OH:9])[c:10]([O:11][CH3:13])[cH:12]1",
+    "correct_smiles": "CC(C)(C)c1ccc(O)c(O)c1",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":13}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 13
+      }
+    },
+    "restored_smiles": "CC(C)(C)c1ccc(O)c(O)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000000",
+    "op_type": "change_atom_element",
+    "image_path": "images/000000.png",
+    "wrong_smiles_mapped": "[CH3:1][C:2]([SH:3])([CH3:4])[c:5]1[cH:6][cH:7][c:8]([OH:9])[c:10]([OH:11])[cH:12]1",
+    "correct_smiles": "CC(C)(C)c1ccc(O)c(O)c1",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":3},\"element\":\"C\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 3
+      },
+      "element": "C",
+      "charge": 0
+    },
+    "restored_smiles": "CC(C)(C)c1ccc(O)c(O)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000011",
+    "op_type": "add_atom",
+    "image_path": "images/000011.png",
+    "wrong_smiles_mapped": "[NH2:1][CH:2]([CH2:3][c:4]1[cH:5][cH:6][cH:7][c:8]([OH:9])[cH:10]1)[CH:11]=[O:12]",
+    "correct_smiles": "NC(Cc1cccc(O)c1)C(=O)O",
+    "predicted_raw": "{\"type\":\"AddGroup\",\"anchor\":{\"map_num\":11},\"group\":\"OH\"}",
+    "predicted_action": {
+      "type": "AddGroup",
+      "anchor": {
+        "map_num": 11
+      },
+      "group": "OH"
+    },
+    "restored_smiles": "NC(Cc1cccc(O)c1)C(=O)O",
+    "exec_match": true,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000008",
+    "op_type": "swap_substituents",
+    "image_path": "images/000008.png",
+    "wrong_smiles_mapped": "[CH3:1][C:2]([CH3:3])([CH3:4])[c:10]1[c:8]([OH:9])[cH:7][cH:6][c:5]([OH:11])[cH:12]1",
+    "correct_smiles": "CC(C)(C)c1ccc(O)c(O)c1",
+    "predicted_raw": "{\"type\":\"MoveSubstituent\",\"substituent\":{\"map_num\":9},\"from_atom\":{\"map_num\":8},\"to_atom\":{\"map_num\":6}}",
+    "predicted_action": {
+      "type": "MoveSubstituent",
+      "substituent": {
+        "map_num": 9
+      },
+      "from_atom": {
+        "map_num": 8
+      },
+      "to_atom": {
+        "map_num": 6
+      }
+    },
+    "restored_smiles": "CC(C)(C)c1ccc(O)c(O)c1",
+    "exec_match": true,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000014",
+    "op_type": "remove_bond",
+    "image_path": "images/000014.png",
+    "wrong_smiles_mapped": "[NH2:1][CH:2]([CH2:3][c:4]1[cH:5][cH:6][c:7]2[c:8]([cH:10]1)[O:9]2)[C:11](=[O:12])[OH:13]",
+    "correct_smiles": "NC(Cc1cccc(O)c1)C(=O)O",
+    "predicted_raw": "{\"type\":\"RemoveBond\",\"bond\":{\"atom1\":{\"map_num\":8},\"atom2\":{\"map_num\":9}}}",
+    "predicted_action": {
+      "type": "RemoveBond",
+      "bond": {
+        "atom1": {
+          "map_num": 8
+        },
+        "atom2": {
+          "map_num": 9
+        }
+      }
+    },
+    "restored_smiles": "NC(Cc1ccc(O)cc1)C(=O)O",
+    "exec_match": false,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000015",
+    "op_type": "add_bond",
+    "image_path": "images/000015.png",
+    "wrong_smiles_mapped": "[NH2:1][CH:2]([CH2:3][c:4]1[cH:5][cH:6][cH:7][c:8]([OH:9])[cH:10]1)[CH:11]=[O:12].[OH2:13]",
+    "correct_smiles": "NC(Cc1cccc(O)c1)C(=O)O",
+    "predicted_raw": "{\"type\":\"AddBond\",\"bond\":{\"atom1\":{\"map_num\":11},\"atom2\":{\"map_num\":13}},\"order\":\"SINGLE\"}",
+    "predicted_action": {
+      "type": "AddBond",
+      "bond": {
+        "atom1": {
+          "map_num": 11
+        },
+        "atom2": {
+          "map_num": 13
+        }
+      },
+      "order": "SINGLE"
+    },
+    "restored_smiles": "NC(Cc1cccc(O)c1)C(=O)O",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000013",
+    "op_type": "change_bond_order",
+    "image_path": "images/000013.png",
+    "wrong_smiles_mapped": "[NH:1]=[C:2]([CH2:3][c:4]1[cH:5][cH:6][cH:7][c:8]([OH:9])[cH:10]1)[C:11](=[O:12])[OH:13]",
+    "correct_smiles": "NC(Cc1cccc(O)c1)C(=O)O",
+    "predicted_raw": "{\"type\":\"ChangeBond\",\"bond\":{\"atom1\":{\"map_num\":1},\"atom2\":{\"map_num\":2}},\"order\":\"SINGLE\"}",
+    "predicted_action": {
+      "type": "ChangeBond",
+      "bond": {
+        "atom1": {
+          "map_num": 1
+        },
+        "atom2": {
+          "map_num": 2
+        }
+      },
+      "order": "SINGLE"
+    },
+    "restored_smiles": "NC(Cc1cccc(O)c1)C(=O)O",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000019",
+    "op_type": "change_atom_element",
+    "image_path": "images/000019.png",
+    "wrong_smiles_mapped": "[CH3:1][c:2]1[cH:3][cH:4][c:5]2[cH:6][c:7]3[c:8]([cH:9][cH:10][c:11]4[cH:12][c:13]([SH:14])[cH:15][cH:16][c:17]34)[cH:18][c:19]2[cH:20]1",
+    "correct_smiles": "Cc1ccc2cc3c(ccc4cc(C)ccc43)cc2c1",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":14},\"element\":\"C\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 14
+      },
+      "element": "C",
+      "charge": 0
+    },
+    "restored_smiles": "Cc1ccc2cc3c(ccc4cc(C)ccc43)cc2c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000017",
+    "op_type": "add_functional_group",
+    "image_path": "images/000017.png",
+    "wrong_smiles_mapped": "[NH2:1][CH:2]([CH2:3][c:4]1[cH:5][cH:6][cH:7][cH:8][cH:9]1)[C:10](=[O:11])[OH:12]",
+    "correct_smiles": "NC(Cc1cccc(O)c1)C(=O)O",
+    "predicted_raw": "{\"type\":\"AddGroup\",\"anchor\":{\"map_num\":7},\"group\":\"OH\"}",
+    "predicted_action": {
+      "type": "AddGroup",
+      "anchor": {
+        "map_num": 7
+      },
+      "group": "OH"
+    },
+    "restored_smiles": "NC(Cc1ccc(O)cc1)C(=O)O",
+    "exec_match": false,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000016",
+    "op_type": "remove_functional_group",
+    "image_path": "images/000016.png",
+    "wrong_smiles_mapped": "[NH2:1][CH:2]([CH2:3][c:4]1[cH:5][cH:6][c:7]([F:14])[c:8]([OH:9])[cH:10]1)[C:11](=[O:12])[OH:13]",
+    "correct_smiles": "NC(Cc1cccc(O)c1)C(=O)O",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":14}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 14
+      }
+    },
+    "restored_smiles": "NC(Cc1cccc(O)c1)C(=O)O",
+    "exec_match": true,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000018",
+    "op_type": "move_substituent",
+    "image_path": "images/000018.png",
+    "wrong_smiles_mapped": "[NH2:1][CH:2]([CH2:3][c:4]1[cH:5][cH:6][cH:7][cH:8][c:10]1[OH:9])[C:11](=[O:12])[OH:13]",
+    "correct_smiles": "NC(Cc1cccc(O)c1)C(=O)O",
+    "predicted_raw": "{\"type\":\"MoveSubstituent\",\"substituent\":{\"map_num\":9},\"from_atom\":{\"map_num\":10},\"to_atom\":{\"map_num\":7}}",
+    "predicted_action": {
+      "type": "MoveSubstituent",
+      "substituent": {
+        "map_num": 9
+      },
+      "from_atom": {
+        "map_num": 10
+      },
+      "to_atom": {
+        "map_num": 7
+      }
+    },
+    "restored_smiles": "NC(Cc1ccc(O)cc1)C(=O)O",
+    "exec_match": false,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000023",
+    "op_type": "add_bond",
+    "image_path": "images/000023.png",
+    "wrong_smiles_mapped": "[CH4:1].[cH:2]1[cH:3][cH:4][c:5]2[cH:6][c:7]3[c:8]([cH:9][cH:10][c:11]4[cH:12][c:13]([CH3:14])[cH:15][cH:16][c:17]34)[cH:18][c:19]2[cH:20]1",
+    "correct_smiles": "Cc1ccc2cc3c(ccc4cc(C)ccc43)cc2c1",
+    "predicted_raw": "{\"type\":\"AddBond\",\"bond\":{\"atom1\":{\"map_num\":1},\"atom2\":{\"map_num\":2}},\"order\":\"SINGLE\"}",
+    "predicted_action": {
+      "type": "AddBond",
+      "bond": {
+        "atom1": {
+          "map_num": 1
+        },
+        "atom2": {
+          "map_num": 2
+        }
+      },
+      "order": "SINGLE"
+    },
+    "restored_smiles": "Cc1ccc2cc3c(ccc4cc(C)ccc43)cc2c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000024",
+    "op_type": "remove_functional_group",
+    "image_path": "images/000024.png",
+    "wrong_smiles_mapped": "[CH3:1][c:2]1[cH:3][cH:4][c:5]2[c:6]([CH3:21])[c:7]3[c:8]([cH:9][cH:10][c:11]4[cH:12][c:13]([CH3:14])[cH:15][cH:16][c:17]34)[cH:18][c:19]2[cH:20]1",
+    "correct_smiles": "Cc1ccc2cc3c(ccc4cc(C)ccc43)cc2c1",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":21}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 21
+      }
+    },
+    "restored_smiles": "Cc1ccc2cc3c(ccc4cc(C)ccc43)cc2c1",
+    "exec_match": true,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000022",
+    "op_type": "remove_bond",
+    "image_path": "images/000022.png",
+    "wrong_smiles_mapped": "[CH3:1][c:2]1[cH:3][c:4]2[c:5]3[c:6]-2[c:7]2[c:8]([cH:9][cH:10][c:11]4[cH:12][c:13]([CH3:14])[cH:15][cH:16][c:17]24)[cH:18][c:19]3[cH:20]1",
+    "correct_smiles": "Cc1ccc2cc3c(ccc4cc(C)ccc43)cc2c1",
+    "predicted_raw": "",
+    "predicted_action": null,
+    "restored_smiles": null,
+    "exec_match": false,
+    "type_match": false,
+    "parse_error": true,
+    "exec_error": null
+  },
+  {
+    "id": "000020",
+    "op_type": "remove_atom",
+    "image_path": "images/000020.png",
+    "wrong_smiles_mapped": "[CH3:1][c:2]1[cH:3][cH:4][c:5]2[cH:6][c:7]3[c:8]([cH:9][cH:10][c:11]4[cH:12][c:13]([CH2:14][OH:21])[cH:15][cH:16][c:17]34)[cH:18][c:19]2[cH:20]1",
+    "correct_smiles": "Cc1ccc2cc3c(ccc4cc(C)ccc43)cc2c1",
+    "predicted_raw": "{\"type\":\"RemoveGroup\",\"anchor\":{\"map_num\":14},\"group\":\"OH\"}",
+    "predicted_action": {
+      "type": "RemoveGroup",
+      "anchor": {
+        "map_num": 14
+      },
+      "group": "OH"
+    },
+    "restored_smiles": "Cc1ccc2cc3c(ccc4cc(C)ccc43)cc2c1",
+    "exec_match": true,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000028",
+    "op_type": "remove_atom",
+    "image_path": "images/000028.png",
+    "wrong_smiles_mapped": "[O:1]=[S:2](=[O:3])([OH:4])[c:5]1[cH:6][cH:7][cH:8][c:9]([N:10]=[N:11][c:12]2[cH:13][cH:14][c:15]([N:16]=[N:17][c:18]3[cH:19][cH:20][c:21]([NH:22][c:23]4[cH:24][cH:25][cH:26][cH:27][c:28]4[OH:46])[c:29]4[c:30]([S:31](=[O:32])(=[O:33])[OH:34])[cH:35][cH:36][cH:37][c:38]34)[c:39]3[cH:40][cH:41][cH:42][cH:43][c:44]23)[cH:45]1",
+    "correct_smiles": "O=S(=O)(O)c1cccc(N=Nc2ccc(N=Nc3ccc(Nc4ccccc4)c4c(S(=O)(=O)O)cccc34)c3ccccc23)c1",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":46}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 46
+      }
+    },
+    "restored_smiles": "O=S(=O)(O)c1cccc(N=Nc2ccc(N=Nc3ccc(Nc4ccccc4)c4c(S(=O)(=O)O)cccc34)c3ccccc23)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000025",
+    "op_type": "add_functional_group",
+    "image_path": "images/000025.png",
+    "wrong_smiles_mapped": "[cH:1]1[cH:2][cH:3][c:4]2[cH:5][c:6]3[c:7]([cH:8][cH:9][c:10]4[cH:11][c:12]([CH3:13])[cH:14][cH:15][c:16]34)[cH:17][c:18]2[cH:19]1",
+    "correct_smiles": "Cc1ccc2cc3c(ccc4cc(C)ccc43)cc2c1",
+    "predicted_raw": "{\"type\":\"AddGroup\",\"anchor\":{\"map_num\":2},\"group\":\"CH3\"}",
+    "predicted_action": {
+      "type": "AddGroup",
+      "anchor": {
+        "map_num": 2
+      },
+      "group": "CH3"
+    },
+    "restored_smiles": "Cc1ccc2cc3ccc4cc(C)ccc4c3cc2c1",
+    "exec_match": false,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000029",
+    "op_type": "add_atom",
+    "image_path": "images/000029.png",
+    "wrong_smiles_mapped": "[O:1]=[S:2](=[O:3])([OH:4])[c:5]1[cH:6][cH:7][cH:8][c:9]([N:10]=[N:11][c:12]2[cH:13][cH:14][c:15]([N:16]=[N:17][c:18]3[cH:19][cH:20][c:21]([NH:22][c:23]4[cH:24][cH:25][cH:26][cH:27][cH:28]4)[c:29]4[c:30]([S:31](=[O:32])[OH:33])[cH:34][cH:35][cH:36][c:37]34)[c:38]3[cH:39][cH:40][cH:41][cH:42][c:43]23)[cH:44]1",
+    "correct_smiles": "O=S(=O)(O)c1cccc(N=Nc2ccc(N=Nc3ccc(Nc4ccccc4)c4c(S(=O)(=O)O)cccc34)c3ccccc23)c1",
+    "predicted_raw": "{\"type\":\"AddAtom\",\"anchor\":{\"map_num\":31},\"element\":\"O\",\"bond_order\":\"DOUBLE\"}",
+    "predicted_action": {
+      "type": "AddAtom",
+      "anchor": {
+        "map_num": 31
+      },
+      "element": "O",
+      "bond_order": "DOUBLE"
+    },
+    "restored_smiles": "O=S(=O)(O)c1cccc(N=Nc2ccc(N=Nc3ccc(Nc4ccccc4)c4c(S(=O)(=O)O)cccc34)c3ccccc23)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000021",
+    "op_type": "add_atom",
+    "image_path": "images/000021.png",
+    "wrong_smiles_mapped": "[CH3:1][c:2]1[cH:3][cH:4][c:5]2[cH:6][c:7]3[c:8]([cH:9][cH:10][c:11]4[cH:12][cH:13][cH:14][cH:15][c:16]34)[cH:17][c:18]2[cH:19]1",
+    "correct_smiles": "Cc1ccc2cc3c(ccc4cc(C)ccc43)cc2c1",
+    "predicted_raw": "",
+    "predicted_action": null,
+    "restored_smiles": null,
+    "exec_match": false,
+    "type_match": false,
+    "parse_error": true,
+    "exec_error": null
+  },
+  {
+    "id": "000033",
+    "op_type": "add_bond",
+    "image_path": "images/000033.png",
+    "wrong_smiles_mapped": "[O:1]=[S:2]([OH:4])[c:5]1[cH:6][cH:7][cH:8][c:9]([N:10]=[N:11][c:12]2[cH:13][cH:14][c:15]([N:16]=[N:17][c:18]3[cH:19][cH:20][c:21]([NH:22][c:23]4[cH:24][cH:25][cH:26][cH:27][cH:28]4)[c:29]4[c:30]([S:31](=[O:32])(=[O:33])[OH:34])[cH:35][cH:36][cH:37][c:38]34)[c:39]3[cH:40][cH:41][cH:42][cH:43][c:44]23)[cH:45]1.[OH2:3]",
+    "correct_smiles": "O=S(=O)(O)c1cccc(N=Nc2ccc(N=Nc3ccc(Nc4ccccc4)c4c(S(=O)(=O)O)cccc34)c3ccccc23)c1",
+    "predicted_raw": "{\"type\":\"AddBond\",\"bond\":{\"atom1\":{\"map_num\":2},\"atom2\":{\"map_num\":3}},\"order\":\"DOUBLE\"}",
+    "predicted_action": {
+      "type": "AddBond",
+      "bond": {
+        "atom1": {
+          "map_num": 2
+        },
+        "atom2": {
+          "map_num": 3
+        }
+      },
+      "order": "DOUBLE"
+    },
+    "restored_smiles": "O=S(=O)(O)c1cccc(N=Nc2ccc(N=Nc3ccc(Nc4ccccc4)c4c(S(=O)(=O)O)cccc34)c3ccccc23)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000027",
+    "op_type": "swap_substituents",
+    "image_path": "images/000027.png",
+    "wrong_smiles_mapped": "[CH3:1][C:2]1=[CH:20][c:19]2[c:5]3[cH:6][c:7]([c:8]([cH:18]2)[CH:4]=[CH:3]1)-[c:17]1[c:11]([cH:12][c:13]([CH3:14])[cH:15][cH:16]1)[CH:10]=[CH:9]3",
+    "correct_smiles": "Cc1ccc2cc3c(ccc4cc(C)ccc43)cc2c1",
+    "predicted_raw": "",
+    "predicted_action": null,
+    "restored_smiles": null,
+    "exec_match": false,
+    "type_match": false,
+    "parse_error": true,
+    "exec_error": null
+  },
+  {
+    "id": "000030",
+    "op_type": "change_charge",
+    "image_path": "images/000030.png",
+    "wrong_smiles_mapped": "[O:1]=[S:2](=[O:3])([OH:4])[c:5]1[cH:6][cH:7][cH:8][c:9]([N:10]=[N:11][c:12]2[cH:13][cH:14][c:15]([N:16]=[NH+:17][c:18]3[cH:19][cH:20][c:21]([NH:22][c:23]4[cH:24][cH:25][cH:26][cH:27][cH:28]4)[c:29]4[c:30]([S:31](=[O:32])(=[O:33])[OH:34])[cH:35][cH:36][cH:37][c:38]34)[c:39]3[cH:40][cH:41][cH:42][cH:43][c:44]23)[cH:45]1",
+    "correct_smiles": "O=S(=O)(O)c1cccc(N=Nc2ccc(N=Nc3ccc(Nc4ccccc4)c4c(S(=O)(=O)O)cccc34)c3ccccc23)c1",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":17},\"element\":\"N\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 17
+      },
+      "element": "N",
+      "charge": 0
+    },
+    "restored_smiles": "O=S(=O)(O)c1cccc(N=Nc2ccc(N=Nc3ccc(Nc4ccccc4)c4c(S(=O)(=O)O)cccc34)c3ccccc23)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000031",
+    "op_type": "change_bond_order",
+    "image_path": "images/000031.png",
+    "wrong_smiles_mapped": "[OH:1][SH:2](=[O:3])([OH:4])[c:5]1[cH:6][cH:7][cH:8][c:9]([N:10]=[N:11][c:12]2[cH:13][cH:14][c:15]([N:16]=[N:17][c:18]3[cH:19][cH:20][c:21]([NH:22][c:23]4[cH:24][cH:25][cH:26][cH:27][cH:28]4)[c:29]4[c:30]([S:31](=[O:32])(=[O:33])[OH:34])[cH:35][cH:36][cH:37][c:38]34)[c:39]3[cH:40][cH:41][cH:42][cH:43][c:44]23)[cH:45]1",
+    "correct_smiles": "O=S(=O)(O)c1cccc(N=Nc2ccc(N=Nc3ccc(Nc4ccccc4)c4c(S(=O)(=O)O)cccc34)c3ccccc23)c1",
+    "predicted_raw": "{\"type\":\"ChangeBond\",\"bond\":{\"atom1\":{\"map_num\":2},\"atom2\":{\"map_num\":4}},\"order\":\"DOUBLE\"}",
+    "predicted_action": {
+      "type": "ChangeBond",
+      "bond": {
+        "atom1": {
+          "map_num": 2
+        },
+        "atom2": {
+          "map_num": 4
+        }
+      },
+      "order": "DOUBLE"
+    },
+    "restored_smiles": "O=S(=O)(O)c1cccc(N=Nc2ccc(N=Nc3ccc(Nc4ccccc4)c4c(S(=O)(=O)O)cccc34)c3ccccc23)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000034",
+    "op_type": "remove_functional_group",
+    "image_path": "images/000034.png",
+    "wrong_smiles_mapped": "[O:1]=[S:2](=[O:3])([OH:4])[c:5]1[cH:6][cH:7][cH:8][c:9]([N:10]=[N:11][c:12]2[c:13]([Cl:46])[cH:14][c:15]([N:16]=[N:17][c:18]3[cH:19][cH:20][c:21]([NH:22][c:23]4[cH:24][cH:25][cH:26][cH:27][cH:28]4)[c:29]4[c:30]([S:31](=[O:32])(=[O:33])[OH:34])[cH:35][cH:36][cH:37][c:38]34)[c:39]3[cH:40][cH:41][cH:42][cH:43][c:44]23)[cH:45]1",
+    "correct_smiles": "O=S(=O)(O)c1cccc(N=Nc2ccc(N=Nc3ccc(Nc4ccccc4)c4c(S(=O)(=O)O)cccc34)c3ccccc23)c1",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":46}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 46
+      }
+    },
+    "restored_smiles": "O=S(=O)(O)c1cccc(N=Nc2ccc(N=Nc3ccc(Nc4ccccc4)c4c(S(=O)(=O)O)cccc34)c3ccccc23)c1",
+    "exec_match": true,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000036",
+    "op_type": "change_atom_element",
+    "image_path": "images/000036.png",
+    "wrong_smiles_mapped": "[NH2:1][NH:2][CH2:3][S:4][S:5][c:6]1[cH:7][cH:8][cH:9][cH:10][cH:11]1",
+    "correct_smiles": "NCCSSc1ccccc1",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":2},\"element\":\"C\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 2
+      },
+      "element": "C",
+      "charge": 0
+    },
+    "restored_smiles": "NCCSSc1ccccc1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000038",
+    "op_type": "add_atom",
+    "image_path": "images/000038.png",
+    "wrong_smiles_mapped": "[CH3:1][CH2:2][S:3][S:4][c:5]1[cH:6][cH:7][cH:8][cH:9][cH:10]1",
+    "correct_smiles": "NCCSSc1ccccc1",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":1},\"element\":\"N\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 1
+      },
+      "element": "N",
+      "charge": 0
+    },
+    "restored_smiles": "NCSSc1ccccc1",
+    "exec_match": false,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000037",
+    "op_type": "remove_atom",
+    "image_path": "images/000037.png",
+    "wrong_smiles_mapped": "[NH2:1][CH2:2][CH2:3][S:4][S:5][c:6]1[cH:7][cH:8][cH:9][cH:10][c:11]1[OH:12]",
+    "correct_smiles": "NCCSSc1ccccc1",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":12}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 12
+      }
+    },
+    "restored_smiles": "NCCSSc1ccccc1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000032",
+    "op_type": "remove_bond",
+    "image_path": "images/000032.png",
+    "wrong_smiles_mapped": "[O:1]=[S:2](=[O:3])([OH:4])[c:5]1[cH:6][cH:7][cH:8][c:9]([N:10]=[N:11][c:12]2[cH:13][cH:14][c:15]3[c:39]4[cH:40][cH:41][cH:42][c:43]([c:44]24)-[c:37]2[cH:36][cH:35][c:30]([S:31](=[O:32])(=[O:33])[OH:34])[c:29]4[c:21]([NH:22][c:23]5[cH:24][cH:25][cH:26][cH:27][cH:28]5)[cH:20][cH:19][c:18]([c:38]42)[N:17]=[N:16]3)[cH:45]1",
+    "correct_smiles": "O=S(=O)(O)c1cccc(N=Nc2ccc(N=Nc3ccc(Nc4ccccc4)c4c(S(=O)(=O)O)cccc34)c3ccccc23)c1",
+    "predicted_raw": "{\"type\":\"RemoveBond\",\"bond\":{\"atom1\":{\"map_num\":43},\"atom2\":{\"map_num\":37}}}",
+    "predicted_action": {
+      "type": "RemoveBond",
+      "bond": {
+        "atom1": {
+          "map_num": 43
+        },
+        "atom2": {
+          "map_num": 37
+        }
+      }
+    },
+    "restored_smiles": "O=S(=O)(O)c1cccc(N=Nc2ccc(N=Nc3ccc(Nc4ccccc4)c4c(S(=O)(=O)O)cccc34)c3ccccc23)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000039",
+    "op_type": "change_bond_order",
+    "image_path": "images/000039.png",
+    "wrong_smiles_mapped": "[NH2:1][CH2:2][CH:3]=[SH:4][S:5][c:6]1[cH:7][cH:8][cH:9][cH:10][cH:11]1",
+    "correct_smiles": "NCCSSc1ccccc1",
+    "predicted_raw": "{\"type\":\"ChangeBond\",\"bond\":{\"atom1\":{\"map_num\":3},\"atom2\":{\"map_num\":4}},\"order\":\"SINGLE\"}",
+    "predicted_action": {
+      "type": "ChangeBond",
+      "bond": {
+        "atom1": {
+          "map_num": 3
+        },
+        "atom2": {
+          "map_num": 4
+        }
+      },
+      "order": "SINGLE"
+    },
+    "restored_smiles": "NCCSSc1ccccc1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000035",
+    "op_type": "move_substituent",
+    "image_path": "images/000035.png",
+    "wrong_smiles_mapped": "[O:1]=[S:2](=[O:3])([OH:4])[c:5]1[cH:6][cH:7][cH:8][c:9]([N:10]=[N:11][C:12]2=[CH:13][CH:14]=[C:15]([N:16]=[N:17][c:18]3[cH:19][cH:20][c:21]([NH:22][c:23]4[cH:24][cH:25][cH:26][cH:27][cH:28]4)[c:29]4[c:30]([S:31](=[O:32])(=[O:33])[OH:34])[cH:35][cH:36][cH:37][c:38]34)[c:41]3[cH:40][cH:39][c:44]2[cH:43][cH:42]3)[cH:45]1",
+    "correct_smiles": "O=S(=O)(O)c1cccc(N=Nc2ccc(N=Nc3ccc(Nc4ccccc4)c4c(S(=O)(=O)O)cccc34)c3ccccc23)c1",
+    "predicted_raw": "",
+    "predicted_action": null,
+    "restored_smiles": null,
+    "exec_match": false,
+    "type_match": false,
+    "parse_error": true,
+    "exec_error": null
+  },
+  {
+    "id": "000026",
+    "op_type": "move_substituent",
+    "image_path": "images/000026.png",
+    "wrong_smiles_mapped": "[CH3:1][c:2]1[cH:3][cH:4][c:5]2[cH:6][c:7]3[c:8]([cH:9][cH:10][c:11]4[cH:12][cH:13][c:15]([CH3:14])[cH:16][c:17]34)[cH:18][c:19]2[cH:20]1",
+    "correct_smiles": "Cc1ccc2cc3c(ccc4cc(C)ccc43)cc2c1",
+    "predicted_raw": "",
+    "predicted_action": null,
+    "restored_smiles": null,
+    "exec_match": false,
+    "type_match": false,
+    "parse_error": true,
+    "exec_error": null
+  },
+  {
+    "id": "000043",
+    "op_type": "add_functional_group",
+    "image_path": "images/000043.png",
+    "wrong_smiles_mapped": "[CH3:1][CH2:2][S:3][S:4][c:5]1[cH:6][cH:7][cH:8][cH:9][cH:10]1",
+    "correct_smiles": "NCCSSc1ccccc1",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":1},\"element\":\"N\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 1
+      },
+      "element": "N",
+      "charge": 0
+    },
+    "restored_smiles": "NCSSc1ccccc1",
+    "exec_match": false,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000042",
+    "op_type": "remove_functional_group",
+    "image_path": "images/000042.png",
+    "wrong_smiles_mapped": "[NH2:1][CH2:2][CH:3]([S:4][S:5][c:6]1[cH:7][cH:8][cH:9][cH:10][cH:11]1)[Cl:12]",
+    "correct_smiles": "NCCSSc1ccccc1",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":12}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 12
+      }
+    },
+    "restored_smiles": "NCCSSc1ccccc1",
+    "exec_match": true,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000041",
+    "op_type": "add_bond",
+    "image_path": "images/000041.png",
+    "wrong_smiles_mapped": "[CH3:3][S:4][S:5][c:6]1[cH:7][cH:8][cH:9][cH:10][cH:11]1.[NH2:1][CH3:2]",
+    "correct_smiles": "NCCSSc1ccccc1",
+    "predicted_raw": "{\"type\":\"AddBond\",\"bond\":{\"atom1\":{\"map_num\":2},\"atom2\":{\"map_num\":3}},\"order\":\"SINGLE\"}",
+    "predicted_action": {
+      "type": "AddBond",
+      "bond": {
+        "atom1": {
+          "map_num": 2
+        },
+        "atom2": {
+          "map_num": 3
+        }
+      },
+      "order": "SINGLE"
+    },
+    "restored_smiles": "NCCSSc1ccccc1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000044",
+    "op_type": "change_atom_element",
+    "image_path": "images/000044.png",
+    "wrong_smiles_mapped": "[NH2:1][CH2:2][CH2:3][CH2:4][NH:5][CH2:6][CH2:7][O:8][P:9](=[O:10])([OH:11])[OH:12]",
+    "correct_smiles": "NCCCNCCSP(=O)(O)O",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":8},\"element\":\"S\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 8
+      },
+      "element": "S",
+      "charge": 0
+    },
+    "restored_smiles": "NCCCNCCSP(=O)(O)O",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000045",
+    "op_type": "remove_atom",
+    "image_path": "images/000045.png",
+    "wrong_smiles_mapped": "[NH2:1][CH:2]([CH2:3][CH2:4][NH:5][CH2:6][CH2:7][S:8][P:9](=[O:10])([OH:11])[OH:12])[OH:13]",
+    "correct_smiles": "NCCCNCCSP(=O)(O)O",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":13}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 13
+      }
+    },
+    "restored_smiles": "NCCCNCCSP(=O)(O)O",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000046",
+    "op_type": "add_atom",
+    "image_path": "images/000046.png",
+    "wrong_smiles_mapped": "[NH2:1][CH2:2][CH2:3][CH2:4][NH:5][CH2:6][CH2:7][S:8][PH:9](=[O:10])[OH:11]",
+    "correct_smiles": "NCCCNCCSP(=O)(O)O",
+    "predicted_raw": "{\"type\":\"AddGroup\",\"anchor\":{\"map_num\":9},\"group\":\"OH\"}",
+    "predicted_action": {
+      "type": "AddGroup",
+      "anchor": {
+        "map_num": 9
+      },
+      "group": "OH"
+    },
+    "restored_smiles": "NCCCNCCSP(=O)(O)O",
+    "exec_match": true,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000040",
+    "op_type": "remove_bond",
+    "image_path": "images/000040.png",
+    "wrong_smiles_mapped": "[NH2:1][CH2:2][CH2:3][S:4][S:5][c:6]1[c:7]2[cH:8][cH:9][cH:10][c:11]1-2",
+    "correct_smiles": "NCCSSc1ccccc1",
+    "predicted_raw": "{\"type\":\"RemoveBond\",\"bond\":{\"atom1\":{\"map_num\":7},\"atom2\":{\"map_num\":11}}}",
+    "predicted_action": {
+      "type": "RemoveBond",
+      "bond": {
+        "atom1": {
+          "map_num": 7
+        },
+        "atom2": {
+          "map_num": 11
+        }
+      }
+    },
+    "restored_smiles": "NCCSSc1ccccc1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000049",
+    "op_type": "remove_bond",
+    "image_path": "images/000049.png",
+    "wrong_smiles_mapped": "[NH2:1][CH2:2][CH:3]1[CH2:4][NH:5][CH2:6][CH2:7][S:8][P:9](=[O:10])([OH:11])[O:12]1",
+    "correct_smiles": "NCCCNCCSP(=O)(O)O",
+    "predicted_raw": "{\"type\":\"RemoveBond\",\"bond\":{\"atom1\":{\"map_num\":3},\"atom2\":{\"map_num\":12}}}",
+    "predicted_action": {
+      "type": "RemoveBond",
+      "bond": {
+        "atom1": {
+          "map_num": 3
+        },
+        "atom2": {
+          "map_num": 12
+        }
+      }
+    },
+    "restored_smiles": "NCCCNCCSP(=O)(O)O",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000048",
+    "op_type": "change_bond_order",
+    "image_path": "images/000048.png",
+    "wrong_smiles_mapped": "[NH2:1][CH2:2][CH2:3][CH2:4][NH:5][CH2:6][CH2:7][S:8][PH:9]([OH:10])([OH:11])[OH:12]",
+    "correct_smiles": "NCCCNCCSP(=O)(O)O",
+    "predicted_raw": "{\"type\":\"ChangeBond\",\"bond\":{\"atom1\":{\"map_num\":9},\"atom2\":{\"map_num\":12}},\"order\":\"DOUBLE\"}",
+    "predicted_action": {
+      "type": "ChangeBond",
+      "bond": {
+        "atom1": {
+          "map_num": 9
+        },
+        "atom2": {
+          "map_num": 12
+        }
+      },
+      "order": "DOUBLE"
+    },
+    "restored_smiles": "NCCCNCCSP(=O)(O)O",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000047",
+    "op_type": "change_charge",
+    "image_path": "images/000047.png",
+    "wrong_smiles_mapped": "[NH2:1][CH2:2][CH2:3][CH2:4][NH:5][CH2:6][CH2:7][S:8][P:9](=[OH+:10])([OH:11])[OH:12]",
+    "correct_smiles": "NCCCNCCSP(=O)(O)O",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":10},\"element\":\"O\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 10
+      },
+      "element": "O",
+      "charge": 0
+    },
+    "restored_smiles": "NCCCNCCSP(=O)(O)O",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000051",
+    "op_type": "remove_functional_group",
+    "image_path": "images/000051.png",
+    "wrong_smiles_mapped": "[NH2:1][CH:2]([CH2:3][CH2:4][NH:5][CH2:6][CH2:7][S:8][P:9](=[O:10])([OH:11])[OH:12])[F:13]",
+    "correct_smiles": "NCCCNCCSP(=O)(O)O",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":13}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 13
+      }
+    },
+    "restored_smiles": "NCCCNCCSP(=O)(O)O",
+    "exec_match": true,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000054",
+    "op_type": "remove_atom",
+    "image_path": "images/000054.png",
+    "wrong_smiles_mapped": "[CH:1]1=[C:2]([NH2:7])[NH:3][CH2:4][N:5]=[CH:6]1",
+    "correct_smiles": "C1=CNCN=C1",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":7}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 7
+      }
+    },
+    "restored_smiles": "C1=CNCN=C1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000052",
+    "op_type": "add_functional_group",
+    "image_path": "images/000052.png",
+    "wrong_smiles_mapped": "[CH3:1][CH2:2][CH2:3][NH:4][CH2:5][CH2:6][S:7][P:8](=[O:9])([OH:10])[OH:11]",
+    "correct_smiles": "NCCCNCCSP(=O)(O)O",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":1},\"element\":\"N\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 1
+      },
+      "element": "N",
+      "charge": 0
+    },
+    "restored_smiles": "NCCNCCSP(=O)(O)O",
+    "exec_match": false,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000053",
+    "op_type": "change_atom_element",
+    "image_path": "images/000053.png",
+    "wrong_smiles_mapped": "[CH:1]1=[CH:2][NH:3][CH2:4][N:5]=[N:6]1",
+    "correct_smiles": "C1=CNCN=C1",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":6},\"element\":\"C\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 6
+      },
+      "element": "C",
+      "charge": 0
+    },
+    "restored_smiles": "C1=CNCN=C1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000055",
+    "op_type": "change_charge",
+    "image_path": "images/000055.png",
+    "wrong_smiles_mapped": "[CH:1]1=[CH:2][NH:3][CH2:4][NH+:5]=[CH:6]1",
+    "correct_smiles": "C1=CNCN=C1",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":5},\"element\":\"N\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 5
+      },
+      "element": "N",
+      "charge": 0
+    },
+    "restored_smiles": "C1=CNCN=C1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000056",
+    "op_type": "change_bond_order",
+    "image_path": "images/000056.png",
+    "wrong_smiles_mapped": "[C:1]1=[CH:2][NH:3][CH2:4][N:5]=[C:6]=1",
+    "correct_smiles": "C1=CNCN=C1",
+    "predicted_raw": "{\"type\":\"ChangeBond\",\"bond\":{\"atom1\":{\"map_num\":6},\"atom2\":{\"map_num\":1}},\"order\":\"SINGLE\"}",
+    "predicted_action": {
+      "type": "ChangeBond",
+      "bond": {
+        "atom1": {
+          "map_num": 6
+        },
+        "atom2": {
+          "map_num": 1
+        }
+      },
+      "order": "SINGLE"
+    },
+    "restored_smiles": "C1=CNCN=C1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000050",
+    "op_type": "add_bond",
+    "image_path": "images/000050.png",
+    "wrong_smiles_mapped": "[CH3:3][CH2:4][NH:5][CH2:6][CH2:7][S:8][P:9](=[O:10])([OH:11])[OH:12].[NH2:1][CH3:2]",
+    "correct_smiles": "NCCCNCCSP(=O)(O)O",
+    "predicted_raw": "{\"type\":\"AddBond\",\"bond\":{\"atom1\":{\"map_num\":2},\"atom2\":{\"map_num\":3}},\"order\":\"SINGLE\"}",
+    "predicted_action": {
+      "type": "AddBond",
+      "bond": {
+        "atom1": {
+          "map_num": 2
+        },
+        "atom2": {
+          "map_num": 3
+        }
+      },
+      "order": "SINGLE"
+    },
+    "restored_smiles": "NCCCNCCSP(=O)(O)O",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000059",
+    "op_type": "change_atom_element",
+    "image_path": "images/000059.png",
+    "wrong_smiles_mapped": "[CH3:1][CH2:2][CH2:3][CH2:4][CH2:5][CH2:6][CH2:7][CH2:8][CH2:9][CH2:10][N:11]([CH3:12])[c:13]1[cH:14][c:15]([CH2:16][SH:17])[cH:18][c:19]([NH:20][C:21]([CH3:22])=[O:23])[cH:24]1",
+    "correct_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":17},\"element\":\"O\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 17
+      },
+      "element": "O",
+      "charge": 0
+    },
+    "restored_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000058",
+    "op_type": "remove_functional_group",
+    "image_path": "images/000058.png",
+    "wrong_smiles_mapped": "[CH:1]1=[C:2]([CH3:7])[NH:3][CH2:4][N:5]=[CH:6]1",
+    "correct_smiles": "C1=CNCN=C1",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":7}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 7
+      }
+    },
+    "restored_smiles": "C1=CNCN=C1",
+    "exec_match": true,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000061",
+    "op_type": "add_atom",
+    "image_path": "images/000061.png",
+    "wrong_smiles_mapped": "[CH3:1][CH2:2][CH2:3][CH2:4][CH2:5][CH2:6][CH2:7][CH2:8][CH2:9][CH2:10][N:11]([CH3:12])[c:13]1[cH:14][c:15]([CH3:16])[cH:17][c:18]([NH:19][C:20]([CH3:21])=[O:22])[cH:23]1",
+    "correct_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "predicted_raw": "{\"type\":\"AddGroup\",\"anchor\":{\"map_num\":16},\"group\":\"OH\"}",
+    "predicted_action": {
+      "type": "AddGroup",
+      "anchor": {
+        "map_num": 16
+      },
+      "group": "OH"
+    },
+    "restored_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "exec_match": true,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000057",
+    "op_type": "remove_bond",
+    "image_path": "images/000057.png",
+    "wrong_smiles_mapped": "[CH:1]1=[CH:2][NH:3][CH:4]2[N:5]=[C:6]12",
+    "correct_smiles": "C1=CNCN=C1",
+    "predicted_raw": "{\"type\":\"RemoveBond\",\"bond\":{\"atom1\":{\"map_num\":4},\"atom2\":{\"map_num\":6}}}",
+    "predicted_action": {
+      "type": "RemoveBond",
+      "bond": {
+        "atom1": {
+          "map_num": 4
+        },
+        "atom2": {
+          "map_num": 6
+        }
+      }
+    },
+    "restored_smiles": "C1=CNCN=C1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000060",
+    "op_type": "remove_atom",
+    "image_path": "images/000060.png",
+    "wrong_smiles_mapped": "[CH3:1][CH:2]([CH2:3][CH2:4][CH2:5][CH2:6][CH2:7][CH2:8][CH2:9][CH2:10][N:11]([CH3:12])[c:13]1[cH:14][c:15]([CH2:16][OH:17])[cH:18][c:19]([NH:20][C:21]([CH3:22])=[O:23])[cH:24]1)[NH2:25]",
+    "correct_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":25}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 25
+      }
+    },
+    "restored_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000065",
+    "op_type": "add_bond",
+    "image_path": "images/000065.png",
+    "wrong_smiles_mapped": "[CH3:1][CH2:2][CH2:3][CH2:4][CH2:5][CH2:6][CH2:7][CH2:8][CH2:9][CH2:10][N:11]([CH3:12])[c:13]1[cH:14][c:15]([CH2:16][OH:17])[cH:18][c:19]([NH2:20])[cH:24]1.[CH:21]([CH3:22])=[O:23]",
+    "correct_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "predicted_raw": "{\"type\":\"AddBond\",\"bond\":{\"atom1\":{\"map_num\":20},\"atom2\":{\"map_num\":21}},\"order\":\"SINGLE\"}",
+    "predicted_action": {
+      "type": "AddBond",
+      "bond": {
+        "atom1": {
+          "map_num": 20
+        },
+        "atom2": {
+          "map_num": 21
+        }
+      },
+      "order": "SINGLE"
+    },
+    "restored_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000063",
+    "op_type": "change_bond_order",
+    "image_path": "images/000063.png",
+    "wrong_smiles_mapped": "[CH3:1][CH2:2][CH2:3][CH2:4][CH2:5][CH:6]=[CH:7][CH2:8][CH2:9][CH2:10][N:11]([CH3:12])[c:13]1[cH:14][c:15]([CH2:16][OH:17])[cH:18][c:19]([NH:20][C:21]([CH3:22])=[O:23])[cH:24]1",
+    "correct_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "predicted_raw": "{\"type\":\"ChangeBond\",\"bond\":{\"atom1\":{\"map_num\":6},\"atom2\":{\"map_num\":7}},\"order\":\"SINGLE\"}",
+    "predicted_action": {
+      "type": "ChangeBond",
+      "bond": {
+        "atom1": {
+          "map_num": 6
+        },
+        "atom2": {
+          "map_num": 7
+        }
+      },
+      "order": "SINGLE"
+    },
+    "restored_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000066",
+    "op_type": "remove_functional_group",
+    "image_path": "images/000066.png",
+    "wrong_smiles_mapped": "[CH3:1][CH:2]([CH2:3][CH2:4][CH2:5][CH2:6][CH2:7][CH2:8][CH2:9][CH2:10][N:11]([CH3:12])[c:13]1[cH:14][c:15]([CH2:16][OH:17])[cH:18][c:19]([NH:20][C:21]([CH3:22])=[O:23])[cH:24]1)[OH:25]",
+    "correct_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":25}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 25
+      }
+    },
+    "restored_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "exec_match": true,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000064",
+    "op_type": "remove_bond",
+    "image_path": "images/000064.png",
+    "wrong_smiles_mapped": "[CH3:1][CH2:2][CH2:3][CH2:4][CH2:5][CH2:6][CH:7]1[CH2:8][CH2:9][CH2:10][N:11]([CH3:12])[c:13]2[cH:14][c:15]([CH2:16][OH:17])[c:18]1[c:19]([NH:20][C:21]([CH3:22])=[O:23])[cH:24]2",
+    "correct_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "predicted_raw": "{\"type\":\"RemoveBond\",\"bond\":{\"atom1\":{\"map_num\":7},\"atom2\":{\"map_num\":18}}}",
+    "predicted_action": {
+      "type": "RemoveBond",
+      "bond": {
+        "atom1": {
+          "map_num": 7
+        },
+        "atom2": {
+          "map_num": 18
+        }
+      }
+    },
+    "restored_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000062",
+    "op_type": "change_charge",
+    "image_path": "images/000062.png",
+    "wrong_smiles_mapped": "[CH3:1][CH2:2][CH2:3][CH2:4][CH2:5][CH2:6][CH2:7][CH2:8][CH2:9][CH2:10][NH+:11]([CH3:12])[c:13]1[cH:14][c:15]([CH2:16][OH:17])[cH:18][c:19]([NH:20][C:21]([CH3:22])=[O:23])[cH:24]1",
+    "correct_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":11},\"element\":\"N\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 11
+      },
+      "element": "N",
+      "charge": 0
+    },
+    "restored_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000067",
+    "op_type": "add_functional_group",
+    "image_path": "images/000067.png",
+    "wrong_smiles_mapped": "[CH3:1][CH2:2][CH2:3][CH2:4][CH2:5][CH2:6][CH2:7][CH2:8][CH2:9][CH2:10][N:11]([CH3:12])[c:13]1[cH:14][c:15]([CH3:16])[cH:17][c:18]([NH:19][C:20]([CH3:21])=[O:22])[cH:23]1",
+    "correct_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "predicted_raw": "{\"type\":\"AddGroup\",\"anchor\":{\"map_num\":16},\"group\":\"OH\"}",
+    "predicted_action": {
+      "type": "AddGroup",
+      "anchor": {
+        "map_num": 16
+      },
+      "group": "OH"
+    },
+    "restored_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000072",
+    "op_type": "change_charge",
+    "image_path": "images/000072.png",
+    "wrong_smiles_mapped": "[O:1]=[C:2]([CH2:3][CH2:4][CH2:5][NH+:6]1[CH2:7][CH2:8][C:9]2([CH2:10][CH2:11]1)[C:12](=[O:13])[NH:14][CH2:15][N:16]2[c:17]1[cH:18][cH:19][cH:20][cH:21][cH:22]1)[c:23]1[cH:24][cH:25][c:26]([F:27])[cH:28][cH:29]1",
+    "correct_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":6},\"element\":\"N\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 6
+      },
+      "element": "N",
+      "charge": 0
+    },
+    "restored_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000069",
+    "op_type": "change_atom_element",
+    "image_path": "images/000069.png",
+    "wrong_smiles_mapped": "[O:1]=[C:2]([CH2:3][CH2:4][CH2:5][N:6]1[CH2:7][CH2:8][C:9]2([CH2:10][O:11]1)[C:12](=[O:13])[NH:14][CH2:15][N:16]2[c:17]1[cH:18][cH:19][cH:20][cH:21][cH:22]1)[c:23]1[cH:24][cH:25][c:26]([F:27])[cH:28][cH:29]1",
+    "correct_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":11},\"element\":\"C\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 11
+      },
+      "element": "C",
+      "charge": 0
+    },
+    "restored_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000071",
+    "op_type": "add_atom",
+    "image_path": "images/000071.png",
+    "wrong_smiles_mapped": "[CH2:1]([CH2:2][CH2:3][CH2:4][N:5]1[CH2:6][CH2:7][C:8]2([CH2:9][CH2:10]1)[C:11](=[O:12])[NH:13][CH2:14][N:15]2[c:16]1[cH:17][cH:18][cH:19][cH:20][cH:21]1)[c:22]1[cH:23][cH:24][c:25]([F:26])[cH:27][cH:28]1",
+    "correct_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "predicted_raw": "{\"type\":\"AddAtom\",\"anchor\":{\"map_num\":1},\"element\":\"O\",\"bond_order\":\"DOUBLE\"}",
+    "predicted_action": {
+      "type": "AddAtom",
+      "anchor": {
+        "map_num": 1
+      },
+      "element": "O",
+      "bond_order": "DOUBLE"
+    },
+    "restored_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000073",
+    "op_type": "change_bond_order",
+    "image_path": "images/000073.png",
+    "wrong_smiles_mapped": "[O:1]=[C:2]([CH:3]=[CH:4][CH2:5][N:6]1[CH2:7][CH2:8][C:9]2([CH2:10][CH2:11]1)[C:12](=[O:13])[NH:14][CH2:15][N:16]2[c:17]1[cH:18][cH:19][cH:20][cH:21][cH:22]1)[c:23]1[cH:24][cH:25][c:26]([F:27])[cH:28][cH:29]1",
+    "correct_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "predicted_raw": "{\"type\":\"ChangeBond\",\"bond\":{\"atom1\":{\"map_num\":3},\"atom2\":{\"map_num\":4}},\"order\":\"SINGLE\"}",
+    "predicted_action": {
+      "type": "ChangeBond",
+      "bond": {
+        "atom1": {
+          "map_num": 3
+        },
+        "atom2": {
+          "map_num": 4
+        }
+      },
+      "order": "SINGLE"
+    },
+    "restored_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000075",
+    "op_type": "add_bond",
+    "image_path": "images/000075.png",
+    "wrong_smiles_mapped": "[CH3:3][CH2:4][CH2:5][N:6]1[CH2:7][CH2:8][C:9]2([CH2:10][CH2:11]1)[C:12](=[O:13])[NH:14][CH2:15][N:16]2[c:17]1[cH:18][cH:19][cH:20][cH:21][cH:22]1.[O:1]=[CH:2][c:23]1[cH:24][cH:25][c:26]([F:27])[cH:28][cH:29]1",
+    "correct_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "predicted_raw": "{\"type\":\"AddBond\",\"bond\":{\"atom1\":{\"map_num\":2},\"atom2\":{\"map_num\":3}},\"order\":\"SINGLE\"}",
+    "predicted_action": {
+      "type": "AddBond",
+      "bond": {
+        "atom1": {
+          "map_num": 2
+        },
+        "atom2": {
+          "map_num": 3
+        }
+      },
+      "order": "SINGLE"
+    },
+    "restored_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000070",
+    "op_type": "remove_atom",
+    "image_path": "images/000070.png",
+    "wrong_smiles_mapped": "[O:1]=[C:2]([CH2:3][CH2:4][CH2:5][N:6]1[CH:7]([OH:30])[CH2:8][C:9]2([CH2:10][CH2:11]1)[C:12](=[O:13])[NH:14][CH2:15][N:16]2[c:17]1[cH:18][cH:19][cH:20][cH:21][cH:22]1)[c:23]1[cH:24][cH:25][c:26]([F:27])[cH:28][cH:29]1",
+    "correct_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":30}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 30
+      }
+    },
+    "restored_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000074",
+    "op_type": "remove_bond",
+    "image_path": "images/000074.png",
+    "wrong_smiles_mapped": "[O:1]=[C:2]([CH:3]1[CH2:4][CH2:5][N:6]2[CH2:7][CH2:8][C:9]3([CH:10]1[CH2:11]2)[C:12](=[O:13])[NH:14][CH2:15][N:16]3[c:17]1[cH:18][cH:19][cH:20][cH:21][cH:22]1)[c:23]1[cH:24][cH:25][c:26]([F:27])[cH:28][cH:29]1",
+    "correct_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "predicted_raw": "{\"type\":\"RemoveBond\",\"bond\":{\"atom1\":{\"map_num\":3},\"atom2\":{\"map_num\":10}}}",
+    "predicted_action": {
+      "type": "RemoveBond",
+      "bond": {
+        "atom1": {
+          "map_num": 3
+        },
+        "atom2": {
+          "map_num": 10
+        }
+      }
+    },
+    "restored_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000076",
+    "op_type": "remove_functional_group",
+    "image_path": "images/000076.png",
+    "wrong_smiles_mapped": "[O:1]=[C:2]([CH2:3][CH2:4][CH2:5][N:6]1[CH2:7][CH2:8][C:9]2([CH2:10][CH2:11]1)[C:12](=[O:13])[NH:14][CH2:15][N:16]2[c:17]1[cH:18][cH:19][cH:20][cH:21][cH:22]1)[c:23]1[cH:24][cH:25][c:26]([F:27])[c:28]([F:30])[cH:29]1",
+    "correct_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":30}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 30
+      }
+    },
+    "restored_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "exec_match": true,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000077",
+    "op_type": "add_functional_group",
+    "image_path": "images/000077.png",
+    "wrong_smiles_mapped": "[O:1]=[C:2]([CH2:3][CH2:4][CH2:5][N:6]1[CH2:7][CH2:8][C:9]2([CH2:10][CH2:11]1)[C:12](=[O:13])[NH:14][CH2:15][N:16]2[c:17]1[cH:18][cH:19][cH:20][cH:21][cH:22]1)[c:23]1[cH:24][cH:25][cH:26][cH:27][cH:28]1",
+    "correct_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "predicted_raw": "{\"type\":\"AddGroup\",\"anchor\":{\"map_num\":26},\"group\":\"F\"}",
+    "predicted_action": {
+      "type": "AddGroup",
+      "anchor": {
+        "map_num": 26
+      },
+      "group": "F"
+    },
+    "restored_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000068",
+    "op_type": "move_substituent",
+    "image_path": "images/000068.png",
+    "wrong_smiles_mapped": "[CH3:1][CH2:2][CH2:3][CH2:4][CH2:5][CH2:6][CH2:7][CH2:8][CH2:9][CH2:10][N:11]([CH3:12])[c:13]1[cH:14][cH:15][cH:18][c:19]([NH:20][C:21]([CH3:22])=[O:23])[c:24]1[CH2:16][OH:17]",
+    "correct_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "predicted_raw": "{\"type\":\"MoveSubstituent\",\"substituent\":{\"map_num\":16},\"from_atom\":{\"map_num\":24},\"to_atom\":{\"map_num\":15}}",
+    "predicted_action": {
+      "type": "MoveSubstituent",
+      "substituent": {
+        "map_num": 16
+      },
+      "from_atom": {
+        "map_num": 24
+      },
+      "to_atom": {
+        "map_num": 15
+      }
+    },
+    "restored_smiles": "CCCCCCCCCCN(C)c1cc(CO)cc(NC(C)=O)c1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000078",
+    "op_type": "move_substituent",
+    "image_path": "images/000078.png",
+    "wrong_smiles_mapped": "[O:1]=[C:2]([CH2:3][CH2:4][CH2:5][N:6]1[CH2:7][CH2:8][C:9]2([CH2:10][CH2:11]1)[C:12](=[O:13])[NH:14][CH2:15][N:16]2[c:17]1[cH:18][cH:19][cH:20][cH:21][cH:22]1)[c:23]1[cH:24][c:25]([F:27])[cH:26][cH:28][cH:29]1",
+    "correct_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "predicted_raw": "{\"type\":\"MoveSubstituent\",\"substituent\":{\"map_num\":27},\"from_atom\":{\"map_num\":25},\"to_atom\":{\"map_num\":26}}",
+    "predicted_action": {
+      "type": "MoveSubstituent",
+      "substituent": {
+        "map_num": 27
+      },
+      "from_atom": {
+        "map_num": 25
+      },
+      "to_atom": {
+        "map_num": 26
+      }
+    },
+    "restored_smiles": "O=C(CCCN1CCC2(CC1)C(=O)NCN2c1ccccc1)c1ccc(F)cc1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000079",
+    "op_type": "change_atom_element",
+    "image_path": "images/000079.png",
+    "wrong_smiles_mapped": "[CH3:1][O:2][c:3]1[cH:4][c:5]2[c:6]([c:7]([O:8][CH3:9])[c:10]1[O:11][CH3:12])-[c:13]1[cH:14][c:15]3[c:16]([cH:17][c:18]1[C:19](=[O:20])[CH:21]1[CH2:22][S:23][C:24](=[O:25])[CH:26]1[CH2:27]2)[O:28][CH2:29][O:30]3",
+    "correct_smiles": "COc1cc2c(c(OC)c1OC)-c1cc3c(cc1C(=O)C1COC(=O)C1C2)OCO3",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":23},\"element\":\"O\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 23
+      },
+      "element": "O",
+      "charge": 0
+    },
+    "restored_smiles": "COc1cc2c(c(OC)c1OC)-c1cc3c(cc1C(=O)C1COC(=O)C1C2)OCO3",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000081",
+    "op_type": "add_atom",
+    "image_path": "images/000081.png",
+    "wrong_smiles_mapped": "[OH:1][c:2]1[cH:3][c:4]2[c:5]([c:6]([O:7][CH3:8])[c:9]1[O:10][CH3:11])-[c:12]1[cH:13][c:14]3[c:15]([cH:16][c:17]1[C:18](=[O:19])[CH:20]1[CH2:21][O:22][C:23](=[O:24])[CH:25]1[CH2:26]2)[O:27][CH2:28][O:29]3",
+    "correct_smiles": "COc1cc2c(c(OC)c1OC)-c1cc3c(cc1C(=O)C1COC(=O)C1C2)OCO3",
+    "predicted_raw": "{\"type\":\"AddAtom\",\"anchor\":{\"map_num\":1},\"element\":\"C\",\"bond_order\":\"SINGLE\"}",
+    "predicted_action": {
+      "type": "AddAtom",
+      "anchor": {
+        "map_num": 1
+      },
+      "element": "C",
+      "bond_order": "SINGLE"
+    },
+    "restored_smiles": "COc1cc2c(c(OC)c1OC)-c1cc3c(cc1C(=O)C1COC(=O)C1C2)OCO3",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000082",
+    "op_type": "change_charge",
+    "image_path": "images/000082.png",
+    "wrong_smiles_mapped": "[CH3:1][O:2][c:3]1[cH:4][c:5]2[c:6]([c:7]([O:8][CH3:9])[c:10]1[O:11][CH3:12])-[c:13]1[cH:14][c:15]3[c:16]([cH:17][c:18]1[C:19](=[O:20])[CH:21]1[CH2:22][O:23][C:24](=[OH+:25])[CH:26]1[CH2:27]2)[O:28][CH2:29][O:30]3",
+    "correct_smiles": "COc1cc2c(c(OC)c1OC)-c1cc3c(cc1C(=O)C1COC(=O)C1C2)OCO3",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":25},\"element\":\"O\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 25
+      },
+      "element": "O",
+      "charge": 0
+    },
+    "restored_smiles": "COc1cc2c(c(OC)c1OC)-c1cc3c(cc1C(=O)C1COC(=O)C1C2)OCO3",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000085",
+    "op_type": "add_bond",
+    "image_path": "images/000085.png",
+    "wrong_smiles_mapped": "[CH3:1][O:2][c:3]1[cH:4][c:5]2[c:6]([cH:7][c:10]1[O:11][CH3:12])-[c:13]1[cH:14][c:15]3[c:16]([cH:17][c:18]1[C:19](=[O:20])[CH:21]1[CH2:22][O:23][C:24](=[O:25])[CH:26]1[CH2:27]2)[O:28][CH2:29][O:30]3.[OH:8][CH3:9]",
+    "correct_smiles": "COc1cc2c(c(OC)c1OC)-c1cc3c(cc1C(=O)C1COC(=O)C1C2)OCO3",
+    "predicted_raw": "{\"type\":\"AddBond\",\"bond\":{\"atom1\":{\"map_num\":7},\"atom2\":{\"map_num\":8}},\"order\":\"SINGLE\"}",
+    "predicted_action": {
+      "type": "AddBond",
+      "bond": {
+        "atom1": {
+          "map_num": 7
+        },
+        "atom2": {
+          "map_num": 8
+        }
+      },
+      "order": "SINGLE"
+    },
+    "restored_smiles": "COc1cc2c(c(OC)c1OC)-c1cc3c(cc1C(=O)C1COC(=O)C1C2)OCO3",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000080",
+    "op_type": "remove_atom",
+    "image_path": "images/000080.png",
+    "wrong_smiles_mapped": "[CH3:1][O:2][c:3]1[cH:4][c:5]2[c:6]([c:7]([O:8][CH3:9])[c:10]1[O:11][CH3:12])-[c:13]1[cH:14][c:15]3[c:16]([cH:17][c:18]1[C:19](=[O:20])[CH:21]1[CH:22]([OH:31])[O:23][C:24](=[O:25])[CH:26]1[CH2:27]2)[O:28][CH2:29][O:30]3",
+    "correct_smiles": "COc1cc2c(c(OC)c1OC)-c1cc3c(cc1C(=O)C1COC(=O)C1C2)OCO3",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":31}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 31
+      }
+    },
+    "restored_smiles": "COc1cc2c(c(OC)c1OC)-c1cc3c(cc1C(=O)C1COC(=O)C1C2)OCO3",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000086",
+    "op_type": "remove_functional_group",
+    "image_path": "images/000086.png",
+    "wrong_smiles_mapped": "[CH3:1][O:2][c:3]1[cH:4][c:5]2[c:6]([c:7]([O:8][CH3:9])[c:10]1[O:11][CH3:12])-[c:13]1[cH:14][c:15]3[c:16]([cH:17][c:18]1[C:19](=[O:20])[C:21]1([NH2:31])[CH2:22][O:23][C:24](=[O:25])[CH:26]1[CH2:27]2)[O:28][CH2:29][O:30]3",
+    "correct_smiles": "COc1cc2c(c(OC)c1OC)-c1cc3c(cc1C(=O)C1COC(=O)C1C2)OCO3",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":31}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 31
+      }
+    },
+    "restored_smiles": "COc1cc2c(c(OC)c1OC)-c1cc3c(cc1C(=O)C1COC(=O)C1C2)OCO3",
+    "exec_match": true,
+    "type_match": false,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000083",
+    "op_type": "change_bond_order",
+    "image_path": "images/000083.png",
+    "wrong_smiles_mapped": "[CH3:1][O:2][c:3]1[cH:4][c:5]2[c:6]([c:7]([O:8][CH3:9])[c:10]1[O:11][CH3:12])-[c:13]1[cH:14][c:15]3[c:16]([cH:17][c:18]1[CH:19]([OH:20])[CH:21]1[CH2:22][O:23][C:24](=[O:25])[CH:26]1[CH2:27]2)[O:28][CH2:29][O:30]3",
+    "correct_smiles": "COc1cc2c(c(OC)c1OC)-c1cc3c(cc1C(=O)C1COC(=O)C1C2)OCO3",
+    "predicted_raw": "{\"type\":\"ChangeBond\",\"bond\":{\"atom1\":{\"map_num\":19},\"atom2\":{\"map_num\":20}},\"order\":\"DOUBLE\"}",
+    "predicted_action": {
+      "type": "ChangeBond",
+      "bond": {
+        "atom1": {
+          "map_num": 19
+        },
+        "atom2": {
+          "map_num": 20
+        }
+      },
+      "order": "DOUBLE"
+    },
+    "restored_smiles": "COc1cc2c(c(OC)c1OC)-c1cc3c(cc1C(=O)C1COC(=O)C1C2)OCO3",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000088",
+    "op_type": "change_atom_element",
+    "image_path": "images/000088.png",
+    "wrong_smiles_mapped": "[F:1][c:2]1[cH:3][cH:4][c:5]([CH:6]([c:7]2[cH:8][cH:9][c:10]([F:11])[cH:12][cH:13]2)[N:14]2[CH2:15][CH2:16][N:17]([NH:18][CH:19]=[CH:20][c:21]3[cH:22][cH:23][cH:24][cH:25][cH:26]3)[CH2:27][CH2:28]2)[cH:29][cH:30]1",
+    "correct_smiles": "Fc1ccc(C(c2ccc(F)cc2)N2CCN(CC=Cc3ccccc3)CC2)cc1",
+    "predicted_raw": "{\"type\":\"ChangeAtom\",\"atom\":{\"map_num\":18},\"element\":\"C\",\"charge\":0}",
+    "predicted_action": {
+      "type": "ChangeAtom",
+      "atom": {
+        "map_num": 18
+      },
+      "element": "C",
+      "charge": 0
+    },
+    "restored_smiles": "Fc1ccc(C(c2ccc(F)cc2)N2CCN(CC=Cc3ccccc3)CC2)cc1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000084",
+    "op_type": "remove_bond",
+    "image_path": "images/000084.png",
+    "wrong_smiles_mapped": "[CH3:1][O:2][c:3]1[cH:4][c:5]2[c:6]([c:7]([O:8][CH3:9])[c:10]1[O:11][CH3:12])-[c:13]1[cH:14][c:15]3[c:16]([c:17]4[c:18]1[C:19](=[O:20])[CH:21]1[CH2:22][O:23][C:24](=[O:25])[C:26]41[CH2:27]2)[O:28][CH2:29][O:30]3",
+    "correct_smiles": "COc1cc2c(c(OC)c1OC)-c1cc3c(cc1C(=O)C1COC(=O)C1C2)OCO3",
+    "predicted_raw": "",
+    "predicted_action": null,
+    "restored_smiles": null,
+    "exec_match": false,
+    "type_match": false,
+    "parse_error": true,
+    "exec_error": null
+  },
+  {
+    "id": "000090",
+    "op_type": "add_atom",
+    "image_path": "images/000090.png",
+    "wrong_smiles_mapped": "[cH:1]1[cH:2][cH:3][c:4]([CH:5]([c:6]2[cH:7][cH:8][c:9]([F:10])[cH:11][cH:12]2)[N:13]2[CH2:14][CH2:15][N:16]([CH2:17][CH:18]=[CH:19][c:20]3[cH:21][cH:22][cH:23][cH:24][cH:25]3)[CH2:26][CH2:27]2)[cH:28][cH:29]1",
+    "correct_smiles": "Fc1ccc(C(c2ccc(F)cc2)N2CCN(CC=Cc3ccccc3)CC2)cc1",
+    "predicted_raw": "{\"type\":\"AddAtom\",\"anchor\":{\"map_num\":1},\"element\":\"F\",\"bond_order\":\"SINGLE\"}",
+    "predicted_action": {
+      "type": "AddAtom",
+      "anchor": {
+        "map_num": 1
+      },
+      "element": "F",
+      "bond_order": "SINGLE"
+    },
+    "restored_smiles": "Fc1ccc(C(c2ccc(F)cc2)N2CCN(CC=Cc3ccccc3)CC2)cc1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  },
+  {
+    "id": "000089",
+    "op_type": "remove_atom",
+    "image_path": "images/000089.png",
+    "wrong_smiles_mapped": "[F:1][c:2]1[cH:3][cH:4][c:5]([CH:6]([c:7]2[cH:8][cH:9][c:10]([F:11])[cH:12][cH:13]2)[N:14]2[CH2:15][CH2:16][N:17]([CH2:18][CH:19]=[CH:20][c:21]3[cH:22][cH:23][cH:24][cH:25][cH:26]3)[CH:27]([CH3:31])[CH2:28]2)[cH:29][cH:30]1",
+    "correct_smiles": "Fc1ccc(C(c2ccc(F)cc2)N2CCN(CC=Cc3ccccc3)CC2)cc1",
+    "predicted_raw": "{\"type\":\"RemoveAtom\",\"atom\":{\"map_num\":31}}",
+    "predicted_action": {
+      "type": "RemoveAtom",
+      "atom": {
+        "map_num": 31
+      }
+    },
+    "restored_smiles": "Fc1ccc(C(c2ccc(F)cc2)N2CCN(CC=Cc3ccccc3)CC2)cc1",
+    "exec_match": true,
+    "type_match": true,
+    "parse_error": false,
+    "exec_error": null
+  }
+]

data/benchmark_summary.json

@@ -0,0 +1,302 @@
+{
+  "gpt-5.4": {
+    "total": 245,
+    "exec_match": 63,
+    "type_match": 66,
+    "parse_error": 0,
+    "exec_error": 45,
+    "by_op": {
+      "add_atom": {
+        "n": 20,
+        "exec_match": 1,
+        "type_match": 0,
+        "parse_error": 0,
+        "exec_error": 5
+      },
+      "add_bond": {
+        "n": 20,
+        "exec_match": 0,
+        "type_match": 3,
+        "parse_error": 0,
+        "exec_error": 6
+      },
+      "add_functional_group": {
+        "n": 20,
+        "exec_match": 2,
+        "type_match": 6,
+        "parse_error": 0,
+        "exec_error": 3
+      },
+      "change_atom_element": {
+        "n": 20,
+        "exec_match": 4,
+        "type_match": 5,
+        "parse_error": 0,
+        "exec_error": 3
+      },
+      "change_bond_order": {
+        "n": 20,
+        "exec_match": 9,
+        "type_match": 14,
+        "parse_error": 0,
+        "exec_error": 2
+      },
+      "change_charge": {
+        "n": 20,
+        "exec_match": 10,
+        "type_match": 10,
+        "parse_error": 0,
+        "exec_error": 0
+      },
+      "flip_chirality": {
+        "n": 20,
+        "exec_match": 2,
+        "type_match": 4,
+        "parse_error": 0,
+        "exec_error": 4
+      },
+      "flip_ez": {
+        "n": 5,
+        "exec_match": 0,
+        "type_match": 0,
+        "parse_error": 0,
+        "exec_error": 1
+      },
+      "move_substituent": {
+        "n": 20,
+        "exec_match": 2,
+        "type_match": 7,
+        "parse_error": 0,
+        "exec_error": 6
+      },
+      "remove_atom": {
+        "n": 20,
+        "exec_match": 13,
+        "type_match": 3,
+        "parse_error": 0,
+        "exec_error": 2
+      },
+      "remove_bond": {
+        "n": 20,
+        "exec_match": 3,
+        "type_match": 4,
+        "parse_error": 0,
+        "exec_error": 6
+      },
+      "remove_functional_group": {
+        "n": 20,
+        "exec_match": 17,
+        "type_match": 10,
+        "parse_error": 0,
+        "exec_error": 1
+      },
+      "swap_substituents": {
+        "n": 20,
+        "exec_match": 0,
+        "type_match": 0,
+        "parse_error": 0,
+        "exec_error": 6
+      }
+    }
+  },
+  "gemini-3.1-pro-preview": {
+    "total": 245,
+    "exec_match": 195,
+    "type_match": 173,
+    "parse_error": 14,
+    "exec_error": 8,
+    "by_op": {
+      "add_atom": {
+        "n": 20,
+        "exec_match": 19,
+        "type_match": 12,
+        "parse_error": 1,
+        "exec_error": 0
+      },
+      "add_bond": {
+        "n": 20,
+        "exec_match": 19,
+        "type_match": 20,
+        "parse_error": 0,
+        "exec_error": 0
+      },
+      "add_functional_group": {
+        "n": 20,
+        "exec_match": 17,
+        "type_match": 10,
+        "parse_error": 0,
+        "exec_error": 1
+      },
+      "change_atom_element": {
+        "n": 20,
+        "exec_match": 20,
+        "type_match": 20,
+        "parse_error": 0,
+        "exec_error": 0
+      },
+      "change_bond_order": {
+        "n": 20,
+        "exec_match": 17,
+        "type_match": 17,
+        "parse_error": 1,
+        "exec_error": 0
+      },
+      "change_charge": {
+        "n": 20,
+        "exec_match": 20,
+        "type_match": 20,
+        "parse_error": 0,
+        "exec_error": 0
+      },
+      "flip_chirality": {
+        "n": 20,
+        "exec_match": 7,
+        "type_match": 12,
+        "parse_error": 4,
+        "exec_error": 0
+      },
+      "flip_ez": {
+        "n": 5,
+        "exec_match": 5,
+        "type_match": 5,
+        "parse_error": 0,
+        "exec_error": 0
+      },
+      "move_substituent": {
+        "n": 20,
+        "exec_match": 11,
+        "type_match": 14,
+        "parse_error": 2,
+        "exec_error": 1
+      },
+      "remove_atom": {
+        "n": 20,
+        "exec_match": 18,
+        "type_match": 17,
+        "parse_error": 1,
+        "exec_error": 1
+      },
+      "remove_bond": {
+        "n": 20,
+        "exec_match": 18,
+        "type_match": 18,
+        "parse_error": 1,
+        "exec_error": 0
+      },
+      "remove_functional_group": {
+        "n": 20,
+        "exec_match": 20,
+        "type_match": 1,
+        "parse_error": 0,
+        "exec_error": 0
+      },
+      "swap_substituents": {
+        "n": 20,
+        "exec_match": 4,
+        "type_match": 7,
+        "parse_error": 4,
+        "exec_error": 5
+      }
+    }
+  },
+  "claude-opus-4-6": {
+    "total": 245,
+    "exec_match": 138,
+    "type_match": 126,
+    "parse_error": 20,
+    "exec_error": 18,
+    "by_op": {
+      "add_atom": {
+        "n": 20,
+        "exec_match": 12,
+        "type_match": 1,
+        "parse_error": 3,
+        "exec_error": 1
+      },
+      "add_bond": {
+        "n": 20,
+        "exec_match": 9,
+        "type_match": 13,
+        "parse_error": 3,
+        "exec_error": 2
+      },
+      "add_functional_group": {
+        "n": 20,
+        "exec_match": 9,
+        "type_match": 14,
+        "parse_error": 2,
+        "exec_error": 0
+      },
+      "change_atom_element": {
+        "n": 20,
+        "exec_match": 15,
+        "type_match": 16,
+        "parse_error": 2,
+        "exec_error": 0
+      },
+      "change_bond_order": {
+        "n": 20,
+        "exec_match": 15,
+        "type_match": 16,
+        "parse_error": 2,
+        "exec_error": 0
+      },
+      "change_charge": {
+        "n": 20,
+        "exec_match": 19,
+        "type_match": 19,
+        "parse_error": 0,
+        "exec_error": 0
+      },
+      "flip_chirality": {
+        "n": 20,
+        "exec_match": 3,
+        "type_match": 4,
+        "parse_error": 4,
+        "exec_error": 1
+      },
+      "flip_ez": {
+        "n": 5,
+        "exec_match": 3,
+        "type_match": 3,
+        "parse_error": 0,
+        "exec_error": 0
+      },
+      "move_substituent": {
+        "n": 20,
+        "exec_match": 4,
+        "type_match": 9,
+        "parse_error": 1,
+        "exec_error": 4
+      },
+      "remove_atom": {
+        "n": 20,
+        "exec_match": 16,
+        "type_match": 8,
+        "parse_error": 1,
+        "exec_error": 1
+      },
+      "remove_bond": {
+        "n": 20,
+        "exec_match": 9,
+        "type_match": 11,
+        "parse_error": 1,
+        "exec_error": 6
+      },
+      "remove_functional_group": {
+        "n": 20,
+        "exec_match": 20,
+        "type_match": 6,
+        "parse_error": 0,
+        "exec_error": 0
+      },
+      "swap_substituents": {
+        "n": 20,
+        "exec_match": 4,
+        "type_match": 6,
+        "parse_error": 1,
+        "exec_error": 3
+      }
+    }
+  }
+}