fields.py

"""The MolPerceive field contract. Written BEFORE any corpus row exists, on purpose.

This module is the single place that answers "what is scored, what is only reported, and
what may never be asked at all". Nothing downstream is allowed to invent a field: the
generator draws from HEADLINE, the scorer scores HEADLINE, and EXCLUDED is a hard refusal
list that the gate re-asserts against every shipped row.

WHY EXCLUDED EXISTS AND WHY IT IS FROZEN FIRST. The chart entry learned that a scorer
silently decides what is winnable (HANDOFF 5.4: a perfect pie chart scores 0). The
inverse failure is worse and is what this file prevents: shipping a field that is either
unscoreable in principle, or so easy that the number flatters us. Deciding the field set
after seeing which fields score well is how a benchmark gets built backwards.

THE CALL CHAIN IS PINNED, NOT MERELY THE VERSION. RDKit exposes several mutually
inconsistent answers for the same chemical question inside ONE release: CalcNumHBD versus
CalcNumLipinskiHBD, Lipinski.NumHAcceptors delegating to the general CalcNumHBA (RDKit
issue 6206), symmetrized SSSR ring counts (cubane gives 6, true SSSR gives 5). Stating
"rdkit 2026.03.4" is therefore not enough to make a label reproducible. RDKIT_CALL_CHAIN
below names the exact expression for every field we score or report, and the scorer prints
it, so a reviewer can reproduce a label without reading our source.
"""
from __future__ import annotations

# The rdkit build every label in this entry was computed with. The scorer WARNS on a
# mismatch rather than failing, so a reviewer with a different pip still gets a usable
# run and can see for themselves which fields moved.
RDKIT_PINNED = "2026.03.4"

# ---------------------------------------------------------------------------
# 1. HEADLINE. Every one carries a verified near-zero external floor.
# ---------------------------------------------------------------------------
# floor evidence, all fetched from the primary source rather than a summary:
#   ChemIQ (arXiv 2505.07735, body text not abstract): GPT-4o carbon counting from
#   SMILES 4.0% (n=50), shortest path canonical 11.1% (n=54), shortest path random
#   5.6% (n=54), atom mapping semi-canonical 0.0% (n=92), atom mapping random 0.0%
#   (n=92).
#   MolBasic (arXiv 2607.03007, Table 1): Qwen3-8B heavy atom counting 6.09%, total
#   bond counting 3.07%; graph-to-SMILES near zero across every model tested.
HEADLINE: dict[str, str] = {
    "element_counts": "symbol to int map, includes hydrogen",
    "formula": "Hill notation string",
    "heavy_atom_count": "int",
    "bond_count": "int, bonds between heavy atoms only",
    "atom_at_index": "element symbol at a given rdkit atom index",
    "path_len": "shortest bond path between two atom indices",
    "smiles_from_graph": "SMILES string, scored by InChIKey identity",
}

# Fields that take an argument from the request, and the argument names they carry.
FIELD_PARAMS: dict[str, tuple[str, ...]] = {
    "atom_at_index": ("k",),
    "path_len": ("i", "j"),
}

# Fields whose value is determined by the molecular GRAPH rather than by a bulk tally.
# Gate 7 requires at least one of these per scored row, so a model cannot pass by
# learning composition statistics without ever traversing the structure.
GRAPH_DETERMINED = ("element_counts", "atom_at_index", "path_len", "smiles_from_graph")

# ---------------------------------------------------------------------------
# 2. SEPARATELY REPORTED. Computed and published, never pooled into the headline.
# ---------------------------------------------------------------------------
SEPARATE_REPORTED: dict[str, str] = {
    "ring_count":
        "GPT-4o already scores 45.8% on ChemIQ ring counting (n=48), which the ChemIQ "
        "authors attribute to their sampled molecules having at most six rings. Not a "
        "near-zero floor, so it is not a headline.",
    "aromatic_ring_count":
        "same compressed denominator as ring_count.",
    "bond_count_by_type":
        "Qwen3-8B already scores 45.81% on MolBasic specific bond type counting.",
    "rotatable_bonds":
        "definition drift: CalcNumRotatableBonds default versus "
        "NumRotatableBondsOptions.Strict give different answers in one rdkit build.",
    "hbd":
        "CalcNumHBD versus CalcNumLipinskiHBD disagree inside a single rdkit version.",
    "hba":
        "Lipinski.NumHAcceptors delegates to the general CalcNumHBA (rdkit issue 6206).",
    "stereocenters":
        "FindPotentialStereo versus the removed legacy implementation disagree.",
    "formal_charge":
        "near constant on this corpus, so it would be free points. See gate 7, the "
        "label entropy check, which is what caught it.",
    "degree_unsaturation":
        "near constant on this corpus for the same reason.",
    "mw":
        "decimal arithmetic on a base whose card reports GSM8K 38.4. Any tolerance we "
        "pick would be arbitrary and would decide the score.",
}

# ---------------------------------------------------------------------------
# 3. EXCLUDED BY CONSTRUCTION. Never a model output, in any slice, ever.
# ---------------------------------------------------------------------------
# Note the deliberate asymmetry on InChIKey: it is excluded as an OUTPUT and is
# simultaneously our dedup key, our train-to-eval leak key, and the scoring key for
# smiles_from_graph. Those are the correct uses of a hash. Emitting one is not.
EXCLUDED: dict[str, str] = {
    "inchikey":
        "a SHA-derived hash of the structure. A chemist who understands the molecule "
        "perfectly scores 0, so the field measures hash recall, not chemistry. It is "
        "the internal dedup key, the leak key and the scoring key for smiles_from_graph "
        "instead.",
    "canonical_smiles":
        "scored by string equality it measures agreement with one implementation's "
        "atom-ranking algorithm. A chemically correct answer can differ from rdkit's "
        "string. smiles_from_graph is scored by InChIKey identity for exactly this "
        "reason.",
    "monoisotopic_mass":
        "four-decimal arithmetic. See mw: any tolerance decides the score.",
    "logp":
        "a fitted parameter sum (Crippen). There is no ground truth to recompute, only "
        "agreement with one parameterisation.",
    "tpsa":
        "a fitted parameter sum (Ertl). Same objection as logp.",
    "iupac_name":
        "no deterministic permissively licensed reference implementation exists, so we "
        "could not recompute the label at scoring time, which is the whole claim.",
}

# ---------------------------------------------------------------------------
# 4. Reason codes, split by what they actually require.
# ---------------------------------------------------------------------------
# CHEMISTRY is the headline abstention number. Establishing these needs rdkit's
# sanitisation to run and report a typed problem; no string inspection can do it.
CHEMISTRY_REASONS = ("valence_error", "kekulization_failure")

# SYNTAX codes are pure string checks and require no chemistry at all. They stay in the
# corpus because a chemist typo is a chemist typo, and they are reported on their own
# line, never pooled into the abstention headline. Pooling them would inflate the one
# number the entry is built around.
SYNTAX_REASONS = ("unbalanced_parenthesis", "unclosed_ring_bond", "unknown_element")

OUT_OF_SCOPE_REASONS = ("element_not_supported", "size_out_of_range")

ALL_REASONS = CHEMISTRY_REASONS + SYNTAX_REASONS + OUT_OF_SCOPE_REASONS
STATUSES = ("ok", "invalid_structure", "out_of_scope")

# Deleted on purpose, recorded so nobody re-adds them:
#   atom_label_absent   unreachable, no generator mutation can produce it
#   multiple_components a substring match on a dot, and a dot-disconnected structure is
#                       a valid multi-component record rather than an error
DELETED_REASONS = {
    "atom_label_absent": "unreachable from any mutation in corrupt.py",
    "multiple_components": "a dot is a valid disconnection, not a parse failure",
}

# ---------------------------------------------------------------------------
# 5. Scope.
# ---------------------------------------------------------------------------
SUPPORTED_ELEMENTS = ("C", "H", "N", "O", "S", "P", "F", "Cl", "Br", "I", "B", "Si")
HEAVY_MIN, HEAVY_MAX = 5, 40
# 41 to 70 heavy atoms is a diagnostic slice only and never enters training or any
# headline eval, so the accuracy-versus-atom-count curve shows where the model breaks
# rather than leaving a reviewer to find it.
DIAG_HEAVY_MAX = 70

# ---------------------------------------------------------------------------
# 6. The pinned call chain. Named in the card, the CONVENTIONS clause and the scorer.
# ---------------------------------------------------------------------------
RDKIT_CALL_CHAIN: dict[str, str] = {
    "parse":
        "Chem.MolFromSmiles(s)",
    "parse_nosanitize":
        "Chem.MolFromSmiles(s, sanitize=False)",
    "element_counts":
        "Counter(a.GetSymbol() for a in Chem.AddHs(Chem.MolFromSmiles(s)).GetAtoms())",
    "formula":
        "rdMolDescriptors.CalcMolFormula(Chem.MolFromSmiles(s))",
    "heavy_atom_count":
        "Chem.MolFromSmiles(s).GetNumHeavyAtoms()",
    "bond_count":
        "Chem.MolFromSmiles(s).GetNumBonds()",
    "atom_at_index":
        "Chem.MolFromSmiles(s).GetAtomWithIdx(k).GetSymbol()",
    "path_len":
        "len(Chem.GetShortestPath(Chem.MolFromSmiles(s), i, j)) - 1",
    "smiles_from_graph":
        "Chem.MolToInchiKey(Chem.MolFromSmiles(pred)) == "
        "Chem.MolToInchiKey(reference built with Chem.RWMol then Chem.SanitizeMol)",
    "chemistry_reason":
        "[p.GetType() for p in "
        "Chem.DetectChemistryProblems(Chem.MolFromSmiles(s, sanitize=False))]",
    "syntax_reason":
        "molperceive.indep_parser.classify_syntax(s)   (no rdkit involved)",
    "leak_key":
        "Chem.MolToInchiKey(Chem.MolFromSmiles(s))",
    # Named for the separately reported group so the card can state them too.
    "ring_count":
        "Chem.MolFromSmiles(s).GetRingInfo().NumRings()   "
        "(symmetrized SSSR: cubane gives 6, true SSSR gives 5)",
    "rotatable_bonds":
        "rdMolDescriptors.CalcNumRotatableBonds(mol, "
        "rdMolDescriptors.NumRotatableBondsOptions.Strict)",
    "hbd":
        "rdMolDescriptors.CalcNumHBD(mol)   (NOT CalcNumLipinskiHBD)",
    "hba":
        "rdMolDescriptors.CalcNumHBA(mol)   (NOT Lipinski.NumHAcceptors)",
}

# ---------------------------------------------------------------------------
# 7. Request trigger phrases. Field selection is scored, so this table is released.
# ---------------------------------------------------------------------------
# The REQUEST block is natural language and carries no machine-readable field list, so
# recovering the requested set from the prose is part of the task. This table is what
# makes that recoverable at all, and the gate asserts the round trip on every row: the
# set recovered from the prose must equal the set the row claims to request. Without
# that assertion an Adaptive Data rewrite could silently change the question.
#
# TWELVE phrasing families. Families 9 to 12 are RESERVED: they never appear in
# training and are the whole content of the mp_para slice.
PHRASING_FAMILIES = tuple(range(1, 13))
RESERVED_FAMILIES = (9, 10, 11, 12)
TRAIN_FAMILIES = tuple(f for f in PHRASING_FAMILIES if f not in RESERVED_FAMILIES)

# field -> family -> phrasing. Each phrasing must contain a trigger substring from
# TRIGGERS[field], which is what the merge gate checks survives an Adaptive Data rewrite.
TRIGGERS: dict[str, tuple[str, ...]] = {
    # These must be MUTUALLY UNAMBIGUOUS: no trigger of one field may appear inside any
    # phrase written for another. assemble._selftest asserts exactly that over the full
    # 7 x 12 phrase table and it fired on the first run, catching three real collisions:
    # "atom count" matched both element_counts and "the heavy atom count"; "heavy atom"
    # matched heavy_atom_count inside "the bond count between heavy atoms"; and
    # "how many bonds" matched bond_count inside "how many bonds apart". Each would have
    # shipped rows whose recovered field set silently disagreed with the label on a
    # SCORED conjunct.
    "element_counts": ("element count", "element counts", "counts of each element",
                       "count of each element", "how many of each element",
                       "per element", "atoms of each element"),
    "formula": ("molecular formula", "formula", "empirical composition"),
    "heavy_atom_count": ("heavy atom", "non hydrogen atom", "heavy atoms total"),
    "bond_count": ("bond count", "number of bonds", "total bonds", "how many bonds",
                   "bonds are drawn", "bonds present"),
    "atom_at_index": ("which element", "what element", "atom at index",
                      "element at position", "sits at index"),
    "path_len": ("shortest path", "bond distance", "path length", "steps between",
                 "how far apart"),
    "smiles_from_graph": ("smiles", "smiles string", "as smiles"),
}


def is_excluded(name: str) -> bool:
    return name.lower() in EXCLUDED


def assert_not_excluded(names) -> None:
    """Called by the generator and by the gate. Refuses rather than warns."""
    bad = sorted(n for n in names if is_excluded(n))
    if bad:
        raise ValueError(
            f"EXCLUDED field(s) requested: {bad}. "
            + "; ".join(f"{n}: {EXCLUDED[n]}" for n in bad))


def hill_formula(counts: dict[str, int]) -> str:
    """Hill notation from an element -> count map.

    Carbon first, hydrogen second, everything else alphabetical. With NO carbon present,
    every element including hydrogen is alphabetical. That second clause is the part
    people get wrong, and phosphoric acid (H3O4P, not H3PO4) is in the frozen hand set
    precisely to keep us honest about it.
    """
    counts = {k: v for k, v in counts.items() if v}
    parts: list[str] = []

    def emit(sym: str) -> None:
        n = counts[sym]
        parts.append(sym if n == 1 else f"{sym}{n}")

    if "C" in counts:
        emit("C")
        if "H" in counts:
            emit("H")
        for sym in sorted(k for k in counts if k not in ("C", "H")):
            emit(sym)
    else:
        for sym in sorted(counts):
            emit(sym)
    return "".join(parts)


def formula_with_charge(counts: dict[str, int], charge: int) -> str:
    """Hill formula plus rdkit's charge suffix, so the two agree by construction."""
    base = hill_formula(counts)
    if charge == 0:
        return base
    sign = "+" if charge > 0 else "-"
    return base + (sign if abs(charge) == 1 else f"{sign}{abs(charge)}")


def _selftest() -> None:
    ok = 0
    # No field may live in two groups at once, which is how a field quietly gets
    # promoted into the headline after the fact.
    assert not (set(HEADLINE) & set(SEPARATE_REPORTED)); ok += 1
    assert not (set(HEADLINE) & set(EXCLUDED)); ok += 1
    assert not (set(SEPARATE_REPORTED) & set(EXCLUDED)); ok += 1
    # Every headline field names its exact rdkit call.
    assert set(HEADLINE) <= set(RDKIT_CALL_CHAIN), sorted(set(HEADLINE) - set(RDKIT_CALL_CHAIN)); ok += 1
    # Every headline field has at least three trigger phrases. The real diversity that
    # matters is the twelve PHRASINGS per field in assemble.PHRASES, not the trigger
    # count, but a field down to one trigger would make recovery a single-string match.
    for f in HEADLINE:
        assert len(TRIGGERS.get(f, ())) >= 3, f
    ok += 1
    # NO trigger of one field may be a substring of a trigger of another. If it were,
    # a phrase could satisfy both fields and recover_fields would return a set the row
    # never claimed, on a conjunct that is scored. Three such collisions existed on the
    # first run of the assemble selftest and this is the check that keeps them gone.
    tcol = [(a, x, b, y)
            for a, ta in TRIGGERS.items() for b, tb in TRIGGERS.items() if a != b
            for x in ta for y in tb if x in y]
    assert not tcol, f"trigger collisions across fields: {tcol}"
    ok += 1
    # assert_not_excluded must actually refuse.
    try:
        assert_not_excluded(["formula", "logp"])
        raise AssertionError("assert_not_excluded failed to fire")
    except ValueError as e:
        assert "logp" in str(e)
        ok += 1
    assert_not_excluded(list(HEADLINE)); ok += 1
    # Hill notation, including the no-carbon clause.
    assert hill_formula({"C": 6, "H": 6, "O": 1}) == "C6H6O"
    assert hill_formula({"C": 1, "Cl": 4}) == "CCl4"
    assert hill_formula({"H": 3, "O": 4, "P": 1}) == "H3O4P"
    assert hill_formula({"B": 1, "F": 4}) == "BF4"
    assert hill_formula({"C": 6, "H": 4, "Br": 1, "F": 1}) == "C6H4BrF"
    ok += 1
    assert formula_with_charge({"C": 4, "H": 12, "N": 1}, 1) == "C4H12N+"
    assert formula_with_charge({"B": 1, "F": 4}, -1) == "BF4-"
    assert formula_with_charge({"C": 1}, -2) == "C-2"
    assert formula_with_charge({"C": 6, "H": 6}, 0) == "C6H6"
    ok += 1
    # Reason codes are disjoint and the deleted ones stay deleted.
    assert len(set(ALL_REASONS)) == len(ALL_REASONS); ok += 1
    assert not (set(ALL_REASONS) & set(DELETED_REASONS)); ok += 1
    # Reserved phrasing families are genuinely held out.
    assert not (set(RESERVED_FAMILIES) & set(TRAIN_FAMILIES))
    assert len(TRAIN_FAMILIES) == 8; ok += 1
    print(f"fields selftest: {ok}/13 OK  "
          f"({len(HEADLINE)} headline, {len(SEPARATE_REPORTED)} reported, "
          f"{len(EXCLUDED)} excluded by construction)")


if __name__ == "__main__":
    _selftest()