Rameau v1: 21,940 records, 4 configs, verified gold, eval harness

.python-version

@@ -0,0 +1 @@
+3.14

README.md

@@ -0,0 +1,191 @@
+---
+pretty_name: "Rameau: Functional Harmony from Notation (Roman Numerals, Cadence, Key)"
+license: cc-by-4.0
+language:
+  - en
+task_categories:
+  - text2text-generation
+tags:
+  - music
+  - music-theory
+  - functional-harmony
+  - roman-numeral-analysis
+  - chord-progression
+  - cadence
+  - key-detection
+  - benchmark
+  - synthetic
+size_categories:
+  - 10K<n<100K
+annotations_creators:
+  - machine-generated
+source_datasets:
+  - original
+configs:
+  - config_name: symbol_to_rn
+    data_files:
+      - split: train
+        path: data/symbol_to_rn/train.jsonl
+      - split: validation
+        path: data/symbol_to_rn/validation.jsonl
+      - split: test
+        path: data/symbol_to_rn/test.jsonl
+  - config_name: notes_to_rn
+    default: true
+    data_files:
+      - split: train
+        path: data/notes_to_rn/train.jsonl
+      - split: validation
+        path: data/notes_to_rn/validation.jsonl
+      - split: test
+        path: data/notes_to_rn/test.jsonl
+  - config_name: pcset_to_rn
+    data_files:
+      - split: train
+        path: data/pcset_to_rn/train.jsonl
+      - split: validation
+        path: data/pcset_to_rn/validation.jsonl
+      - split: test
+        path: data/pcset_to_rn/test.jsonl
+  - config_name: key_id
+    data_files:
+      - split: train
+        path: data/key_id/train.jsonl
+      - split: validation
+        path: data/key_id/validation.jsonl
+      - split: test
+        path: data/key_id/test.jsonl
+---
+
+# Rameau: functional harmony from notation
+
+A **text-to-text** dataset and benchmark for functional-harmony understanding in
+music notation: Roman-numeral analysis, cadence classification, and key
+identification. Progressions are generated by a probabilistic common-practice
+grammar and framed as four tasks of increasing difficulty — the harder tasks
+**hide the answer**, so the data tests harmonic reasoning, not chord-symbol lookup.
+
+Named for Jean-Philippe Rameau, whose *Traité de l'harmonie* (1722) founded the
+theory of functional harmony this dataset teaches.
+
+```
+symbol_to_rn  key: C major / progression: Dm7 G7 Cmaj7   ->  ii7 V7 IM7 / cadence: PAC
+notes_to_rn   key: C major / notes: D4 F4 A4 C5 | ...     ->  ii7 V7 IM7 / cadence: PAC
+pcset_to_rn   key: C major / pitch classes: [2 5 9 0]|... ->  ii7 V7 IM7 / cadence: PAC
+key_id        notes: D4 F4 A4 C5 | G3 B3 D4 F4 | ...      ->  C major
+```
+
+## Configs (tasks)
+
+Load one with `load_dataset("4esv/rameau", "<config>")`. Default: `notes_to_rn`.
+
+| config | task | rows |
+|---|---|---|
+| `symbol_to_rn` | key + chord symbols -> Roman numerals + cadence (easy: chord quality is given) | 5715 |
+| `notes_to_rn` | key + spelled notes -> Roman numerals + cadence (must read each chord) | 5715 |
+| `pcset_to_rn` | key + bass-first pitch-class lists -> Roman numerals + cadence (no spelling) | 5715 |
+| `key_id` | spelled notes, no key -> identify the key (only key-unambiguous phrases) | 4795 |
+| | **total** | **21940** |
+
+## How the gold labels are generated (and why they are trustworthy)
+
+Labels are **not hand-annotated**. A probabilistic functional grammar
+(tonic -> predominant -> dominant -> cadence, with sevenths, inversions,
+cadential 6-4s and secondary dominants) generates each progression *together with*
+its intended Roman-numeral analysis. Every chord is then checked two independent
+ways with [`music21`](https://web.mit.edu/music21/):
+
+- the Roman-numeral label rendered to pitch classes by the roman engine;
+- the printed chord symbol parsed to pitch classes by the chord-symbol parser;
+
+and the item is kept only if the two agree on pitch content **and** bass. On this
+release: **100.00%** chord-level agreement
+(27480/27480 chords;
+5715/5715 instances kept). See `VERIFY.md`.
+
+Built from **845 distinct progression shapes** (key-independent), transposed
+across keys. All content is synthetic; no third-party corpus is redistributed.
+
+## Label convention
+
+Roman numerals follow the **DCML harmony standard**'s feature decomposition
+(`numeral` / `form` / `figbass` / `changes` / `relativeroot`), spec at
+<https://github.com/DCMLab/standards> — we conform to the notation, we do not copy
+DCML data. Major-seventh tonic is `IM7`; secondary dominants use `/` (e.g. `V7/vi`).
+Cadence codes: `PAC` perfect authentic, `IAC` imperfect authentic, `HC` half, `DC` deceptive, `PC` plagal.
+
+## Fields
+
+Common to every config: `input`, `target`, `key`, `mode`, `labels`, `cadence`,
+`analysis` (per-chord DCML features), `source` (`grammar`/`curated`/`single`),
+`category`, `shape_id`. Plus the input representation for the config: `chords`
+(symbols), `notes` (spelled, bass-first), or `pitch_classes` (bass-first).
+
+Accidentals are written the standard way (`Bb`, `F#`, `Cb`). Note for music21
+users: its parsers want `-` for flats — convert `b -> -` in note/root names
+before calling `ChordSymbol` or `Pitch`.
+
+## Splits (leakage-free; test doubles as a benchmark)
+
+The atomic unit is a **shape** (a key-independent Roman-numeral sequence). Each
+shape is hashed to exactly one split, so a shape — and all of its transpositions
+**and all of its task framings** — never crosses splits. Split sizes (rows):
+train 14725 / validation 3571 / test 3644.
+
+## Known limitations
+
+- **Synthetic distribution.** Grammar-generated common-practice progressions, not
+  sampled from real repertoire; the chord distribution is not naturalistic.
+- **PAC vs IAC** is decided by inversion (no notated soprano voice). Cadence rules
+  are strict: an HC must end on a root-position V *triad* (a terminal V7 is not
+  labelled), and a DC requires a root-position dominant (`V65 -> vi` is not one).
+- **key_id** includes only cadence-terminated progressions of >= 3 chords whose
+  notes contain both key-defining degrees (scale degree 4 and the leading tone),
+  so the key is uniquely determined. Without this gate, gold labels can be
+  contestable — e.g. `I V7/V V` in C is note-identical to `IV V7 I` in G, and the
+  G-major reading (a PAC) is arguably stronger. Such phrases are excluded.
+- Harmony only — no voice-leading, melody, or rhythm. No modal mixture / Neapolitan
+  / augmented sixths yet.
+
+## Evaluation
+
+The `test` split is a benchmark: gold is deterministic, so scoring is **exact
+match — no LLM judge**. The repo ships a self-contained harness under `eval/`:
+
+```bash
+# query any OpenAI-compatible endpoint (ollama, vLLM, OpenAI, ...):
+python eval/run_model.py --config notes_to_rn --model <model> --out preds.jsonl
+# score predictions (stdlib only):
+python eval/score.py preds.jsonl --config notes_to_rn --split test
+```
+
+Metrics: `exact` (Roman numerals **and** cadence correct — the headline number),
+`labels_exact`, `chord_acc` (positional), `cadence_acc`; for `key_id`: `exact`,
+`tonic_acc`, `mode_acc`. The zero-shot prompts are versioned in
+`eval/prompts.py`; parsing rules are documented in `eval/README.md`.
+
+## Reproduce
+
+The full generation pipeline ships in this repo (`src/harmony_dataset/`):
+
+```bash
+uv sync && uv run pytest                   # full suite, incl. the eval harness
+uv run python -m harmony_dataset.export    # regenerates data/, README, VERIFY.md
+```
+
+## Licensing
+
+**CC-BY-4.0.** Content is generated by this repository's pipeline from music theory;
+the underlying facts are not copyrightable and no source corpus is redistributed.
+
+## Citation
+
+```
+@misc{rameau,
+  title  = {Rameau: Functional Harmony from Notation (Roman Numerals, Cadence, Key)},
+  author = {Stevens, Axel},
+  year   = {2026},
+  url    = {https://huggingface.co/datasets/4esv/rameau},
+  note   = {Synthetic, grammar-generated, music21-verified, DCML-convention labels}
+}
+```

VERIFY.md

@@ -0,0 +1,60 @@
+# Verification report
+
+## Gold gate (dual-derivation agreement)
+
+| metric | value |
+|---|---|
+| distinct shapes | 845 |
+| instances (shape x key) | 5715 |
+| instances dropped | 0 |
+| chords attempted | 27480 |
+| chord disagreements | 0 |
+| **chord agreement rate** | **100.000%** |
+| total records | 21940 |
+
+## Distribution
+
+- by source: {'curated': 230, 'single': 1440, 'grammar': 20270}
+- by cadence: {'PAC': 7902, 'HC': 3903, None: 1458, 'DC': 4460, 'IAC': 3645, 'PC': 572}
+
+## Same progression, four framings (brief example in C major)
+
+- **symbol_to_rn**
+  - in:  `key: C major  //  progression: Dm7 G7 Cmaj7`
+  - out: `ii7 V7 IM7  //  cadence: PAC`
+- **notes_to_rn**
+  - in:  `key: C major  //  notes: D4 F4 A4 C5 | G4 B4 D5 F5 | C4 E4 G4 B4`
+  - out: `ii7 V7 IM7  //  cadence: PAC`
+- **pcset_to_rn**
+  - in:  `key: C major  //  pitch classes: [2 5 9 0] | [7 11 2 5] | [0 4 7 11]`
+  - out: `ii7 V7 IM7  //  cadence: PAC`
+- **key_id**
+  - in:  `notes: D4 F4 A4 C5 | G4 B4 D5 F5 | C4 E4 G4 B4`
+  - out: `C major`
+
+## Grammar phrases (notes_to_rn, in C major / A minor)
+
+- `A minor`  A4 C5 E5 | D5 F5 A5 | B4 D5 G#5 | E5 G#5 B5 D6 | F5 A5 C6
+  -> `i iv viio6 V7 VI` (DC)
+- `A minor`  A4 C5 E5 | C5 E5 A5 | D5 F5 B5 | E5 G#5 B5
+  -> `i i6 iio6 V` (HC)
+- `C major`  C4 E4 G4 | F4 A4 D5 | G4 C5 E5 | G4 B4 D5
+  -> `I ii6 I64 V` (HC)
+- `A minor`  A4 C5 E5 | A4 C#5 E5 G5 | D5 F5 A5 | E5 G#5 B5
+  -> `i V7/iv iv V` (HC)
+- `A minor`  A4 C5 E5 | F5 A5 C6 | B4 D5 F5 A5 | E5 G#5 B5 D6 | F5 A5 C6
+  -> `i VI ii%7 V7 VI` (DC)
+- `C major`  C4 E4 G4 | D4 F4 A4 C5 | D4 F4 B4 | G4 B4 D5 F5 | A4 C5 E5
+  -> `I ii7 viio6 V7 vi` (DC)
+- `C major`  C4 E4 G4 | E4 G4 B4 | A4 C5 E5 | F4 A4 C5 | G4 B4 D5
+  -> `I iii vi IV V` (HC)
+- `A minor`  A4 C5 E5 | C5 E5 A5 | D5 F5 A5 | E5 G#5 B5
+  -> `i i6 iv V` (HC)
+- `A minor`  C5 E5 A5 | D5 F5 A5 | D5 F5 B5 | E5 G#5 B5 | A4 C5 E5
+  -> `i6 iv iio6 V i` (PAC)
+- `A minor`  A4 C5 E5 | C5 E5 A5 | D5 F5 A5 | B4 D5 G#5 | E5 G#5 B5 D6 | F5 A5 C6
+  -> `i i6 iv viio6 V7 VI` (DC)
+- `A minor`  A4 C5 E5 | F5 A5 C6 | C5 E5 G5 | D5 F5 A5 | E5 G#5 B5 | F5 A5 C6
+  -> `i VI III iv V VI` (DC)
+- `A minor`  A4 C5 E5 | F5 A5 C6 | D5 F5 A5 | E5 G#5 B5
+  -> `i VI iv V` (HC)

eval/README.md

@@ -0,0 +1,47 @@
+# Rameau evaluation protocol
+
+Gold labels are deterministic and machine-verified, so scoring is **exact
+match** — no LLM judge, no partial credit beyond the metrics defined below.
+
+## Protocol
+
+- **Split:** `test` (leakage-free by construction: no progression shape in
+  `test` appears in `train`/`validation` in any key or any task framing).
+- **Prompts:** zero-shot, versioned in `prompts.py` (`PROMPT_VERSION`).
+  Scores are comparable only at equal prompt versions.
+- **Decoding:** temperature 0. `run_model.py` defaults to this.
+
+## Running
+
+```bash
+# any OpenAI-compatible endpoint (ollama, vLLM, LM Studio, OpenAI, OpenRouter)
+python eval/run_model.py --config notes_to_rn --model <model> --out preds.jsonl
+python eval/score.py preds.jsonl --config notes_to_rn --split test
+```
+
+Both scripts are stdlib-only. Predictions are JSONL rows carrying
+`shape_id` + `key` (joined against gold) and a `prediction` string.
+
+## Parsing (lenient wrapper, strict answer)
+
+Before comparison the scorer:
+
+- strips markdown code fences and surrounding prose (the answer is taken from
+  the **last** matching lines of the response);
+- maps unicode music symbols to the dataset's ASCII conventions
+  (`♭→b`, `♯→#`, `°→o`, `ø→%`, superscript digits → digits);
+- drops separator tokens between numerals (`–`, `|`, `,`, `·`, `->`).
+
+It does **not** forgive wrong case (`i64` ≠ `I64` — minor vs major tonic is
+the answer), wrong figures, or missing chords.
+
+## Metrics
+
+| config | metrics |
+|---|---|
+| `*_to_rn` | `exact` (labels **and** cadence correct — headline), `labels_exact`, `chord_acc` (positional), `cadence_acc`, `parse_failures` |
+| `key_id` | `exact` (headline), `tonic_acc`, `mode_acc`, `parse_failures` |
+
+A record whose response cannot be parsed at all counts as wrong (and is
+reported in `parse_failures` so prompt-format problems are visible rather
+than silently penalized).

eval/prompts.py

@@ -0,0 +1,58 @@
+"""Versioned zero-shot prompts for the Rameau benchmark.
+
+Bump PROMPT_VERSION whenever any prompt text changes; scores are only
+comparable at equal prompt versions.
+"""
+from __future__ import annotations
+
+PROMPT_VERSION = "1"
+
+_RN_FORMAT = """\
+Respond with EXACTLY this format and nothing else:
+<Roman numerals separated by single spaces>
+cadence: <PAC|IAC|HC|DC|PC>
+If the phrase does not end with a cadence, output only the Roman-numeral line.
+Use DCML-style Roman numerals as in these examples: I, ii7, V65, viio6, IM7, V7/vi, ii%7, i64.
+(%7 = half-diminished seventh, o = diminished, M7 = major seventh.)"""
+
+_TASK_LINE = {
+    "symbol_to_rn": (
+        "Analyze the chord progression in the given key and provide the "
+        "Roman-numeral analysis of every chord, in order."
+    ),
+    "notes_to_rn": (
+        "Each chord is given as spelled notes, bass note first. Analyze the "
+        "progression in the given key and provide the Roman-numeral analysis "
+        "of every chord, in order."
+    ),
+    "pcset_to_rn": (
+        "Each chord is given as a list of pitch classes (0 = C, 1 = C#/Db, ... "
+        "11 = B), bass pitch class first. Analyze the progression in the given "
+        "key and provide the Roman-numeral analysis of every chord, in order."
+    ),
+}
+
+_KEY_ID_PROMPT = """\
+You are analyzing tonal harmony in the common-practice style.
+Each chord is given as spelled notes, bass note first. Identify the key of the phrase.
+Respond with EXACTLY the key and nothing else, in the form: <Tonic> <major|minor>
+Examples: C major / Eb major / F# minor
+
+{input}"""
+
+_RN_PROMPT = """\
+You are analyzing tonal harmony in the common-practice style.
+{task_line}
+{format_block}
+
+{input}"""
+
+
+def build_prompt(config: str, input_text: str) -> str:
+    if config == "key_id":
+        return _KEY_ID_PROMPT.format(input=input_text)
+    if config in _TASK_LINE:
+        return _RN_PROMPT.format(
+            task_line=_TASK_LINE[config], format_block=_RN_FORMAT, input=input_text
+        )
+    raise ValueError(f"unknown config {config!r}")

eval/run_model.py

@@ -0,0 +1,123 @@
+"""Query a model on a Rameau config and write predictions for score.py.
+
+Works against any OpenAI-compatible chat-completions endpoint (ollama, vLLM,
+LM Studio, OpenAI, OpenRouter, ...). Stdlib only.
+
+Usage:
+    python eval/run_model.py --config notes_to_rn --model qwen2.5:7b \\
+        --base-url http://localhost:11434/v1 --out preds.jsonl
+    python eval/score.py preds.jsonl --config notes_to_rn --split test
+
+Gold records are read from the repo's data/ directory when present, so this
+runs from a fresh `git clone` of the dataset repo with no extra dependencies.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+import urllib.error
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from prompts import PROMPT_VERSION, build_prompt  # noqa: E402
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+RETRIES = 3
+
+
+def load_records(config: str, split: str, data_dir: Path) -> list[dict]:
+    path = data_dir / config / f"{split}.jsonl"
+    if path.exists():
+        with open(path, encoding="utf-8") as fh:
+            return [json.loads(ln) for ln in fh if ln.strip()]
+    try:  # fall back to the Hub if datasets is installed
+        from datasets import load_dataset
+    except ImportError:
+        raise SystemExit(f"{path} not found and `datasets` not installed")
+    return list(load_dataset("4esv/rameau", config, split=split))
+
+
+def complete(base_url: str, api_key: str, model: str, prompt: str,
+             temperature: float, max_tokens: int) -> str:
+    body = json.dumps({
+        "model": model,
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+    }).encode()
+    req = urllib.request.Request(
+        base_url.rstrip("/") + "/chat/completions",
+        data=body,
+        headers={"Content-Type": "application/json",
+                 "Authorization": f"Bearer {api_key}"},
+    )
+    last_err: Exception | None = None
+    for attempt in range(RETRIES):
+        try:
+            with urllib.request.urlopen(req, timeout=300) as resp:
+                data = json.load(resp)
+            return data["choices"][0]["message"]["content"]
+        except (urllib.error.URLError, KeyError, json.JSONDecodeError) as exc:
+            last_err = exc
+            time.sleep(2**attempt)
+    raise RuntimeError(f"request failed after {RETRIES} attempts: {last_err}")
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--config", required=True,
+                    choices=["symbol_to_rn", "notes_to_rn", "pcset_to_rn", "key_id"])
+    ap.add_argument("--split", default="test", choices=["train", "validation", "test"])
+    ap.add_argument("--model", required=True)
+    ap.add_argument("--base-url", default=os.environ.get("OPENAI_BASE_URL",
+                                                         "http://localhost:11434/v1"))
+    ap.add_argument("--api-key", default=os.environ.get("OPENAI_API_KEY", "none"))
+    ap.add_argument("--out", type=Path, required=True)
+    ap.add_argument("--data-dir", type=Path, default=REPO_ROOT / "data")
+    ap.add_argument("--limit", type=int, help="evaluate only the first N records")
+    ap.add_argument("--temperature", type=float, default=0.0)
+    ap.add_argument("--max-tokens", type=int, default=512)
+    ap.add_argument("--concurrency", type=int, default=4)
+    args = ap.parse_args()
+
+    records = load_records(args.config, args.split, args.data_dir)
+    if args.limit:
+        records = records[: args.limit]
+
+    def run_one(rec: dict) -> dict:
+        prompt = build_prompt(args.config, rec["input"])
+        try:
+            pred = complete(args.base_url, args.api_key, args.model, prompt,
+                            args.temperature, args.max_tokens)
+            err = None
+        except RuntimeError as exc:
+            pred, err = "", str(exc)
+        return {
+            "shape_id": rec["shape_id"],
+            "key": rec["key"],
+            "prediction": pred,
+            **({"error": err} if err else {}),
+            "model": args.model,
+            "prompt_version": PROMPT_VERSION,
+        }
+
+    done = errors = 0
+    with ThreadPoolExecutor(max_workers=args.concurrency) as pool, \
+            open(args.out, "w", encoding="utf-8") as fh:
+        for row in pool.map(run_one, records):
+            fh.write(json.dumps(row, ensure_ascii=False) + "\n")
+            done += 1
+            errors += "error" in row
+            if done % 50 == 0:
+                print(f"{done}/{len(records)}", file=sys.stderr)
+    print(f"wrote {done} predictions to {args.out}"
+          + (f" ({errors} request errors)" if errors else ""), file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

eval/score.py

@@ -0,0 +1,196 @@
+"""Deterministic scorer for Rameau predictions. Stdlib only — no dependencies.
+
+Usage:
+    python eval/score.py preds.jsonl --config notes_to_rn --split test
+    python eval/score.py preds.jsonl --gold data/notes_to_rn/test.jsonl
+
+Predictions file: JSONL, one object per record, with a "prediction" field.
+If every object also carries "shape_id" and "key", records are joined on
+(shape_id, key); otherwise predictions are matched to gold by line order.
+
+Parsing is deliberately lenient about *wrapping* (markdown fences, prose
+before the answer, unicode music symbols) and deliberately strict about the
+*answer itself* (Roman numeral case and figures must match exactly).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+
+# unicode variants models like to emit -> dataset ASCII conventions
+_UNICODE = {
+    "♭": "b",   # flat sign
+    "♯": "#",   # sharp sign
+    "°": "o",   # degree (diminished)
+    "ø": "%",   # slashed o (half-diminished)
+    "∅": "%",   # empty set, occasionally used for half-diminished
+    "–": "-", "—": "-",  # dashes
+    "⁰": "0", "¹": "1", "²": "2", "³": "3", "⁴": "4",
+    "⁵": "5", "⁶": "6", "⁷": "7", "⁸": "8", "⁹": "9",
+}
+_SEPARATORS = {"-", "|", ",", ";", "·", "->", "→"}
+_CADENCE_RE = re.compile(r"cadence\s*[:=]\s*([A-Za-z]+)", re.IGNORECASE)
+_KEY_RE = re.compile(r"([A-G](?:b{1,2}|#{1,2})?)[\s-]+(major|minor)", re.IGNORECASE)
+_FENCE_RE = re.compile(r"^```[a-zA-Z]*\s*$")
+
+
+def normalize(text: str) -> str:
+    for k, v in _UNICODE.items():
+        text = text.replace(k, v)
+    lines = [ln for ln in text.splitlines() if not _FENCE_RE.match(ln.strip())]
+    return "\n".join(lines).strip()
+
+
+def parse_rn(text: str) -> tuple[list[str] | None, str | None]:
+    """Extract (labels, cadence) from a model response."""
+    text = normalize(text)
+    lines = [ln.strip().strip("`") for ln in text.splitlines() if ln.strip()]
+    if not lines:
+        return None, None
+
+    cadence = None
+    labels_line = None
+    cad_idx = None
+    for i in range(len(lines) - 1, -1, -1):
+        m = _CADENCE_RE.search(lines[i])
+        if m:
+            cadence = m.group(1).upper().rstrip(".")
+            cad_idx = i
+            break
+
+    if cad_idx is not None:
+        before = lines[cad_idx][: _CADENCE_RE.search(lines[cad_idx]).start()].strip()
+        if before:  # single-line answer: "ii7 V7 I cadence: PAC"
+            labels_line = before
+        else:
+            for j in range(cad_idx - 1, -1, -1):
+                if lines[j]:
+                    labels_line = lines[j]
+                    break
+    else:
+        labels_line = lines[-1]
+
+    if not labels_line:
+        return None, cadence
+
+    tokens = []
+    for tok in labels_line.split():
+        tok = tok.strip("`,.;")
+        if not tok or tok in _SEPARATORS:
+            continue
+        tokens.append(tok)
+    return (tokens or None), cadence
+
+
+def parse_key(text: str) -> str | None:
+    """Extract 'Tonic mode' from a model response (last match wins)."""
+    text = normalize(text)
+    last = None
+    for m in _KEY_RE.finditer(text):
+        tonic, mode = m.group(1), m.group(2)
+        last = f"{tonic[0].upper()}{tonic[1:].lower()} {mode.lower()}"
+    return last
+
+
+def load_jsonl(path: Path) -> list[dict]:
+    with open(path, encoding="utf-8") as fh:
+        return [json.loads(ln) for ln in fh if ln.strip()]
+
+
+def join(gold: list[dict], preds: list[dict]) -> list[tuple[dict, dict]]:
+    if preds and all("shape_id" in p and "key" in p for p in preds):
+        by_id = {(p["shape_id"], p["key"]): p for p in preds}
+        pairs = [(g, by_id[(g["shape_id"], g["key"])]) for g in gold
+                 if (g["shape_id"], g["key"]) in by_id]
+        if len(pairs) < len(preds):
+            print(f"warning: {len(preds) - len(pairs)} predictions matched no gold record",
+                  file=sys.stderr)
+        return pairs
+    if len(preds) != len(gold):
+        raise SystemExit(
+            f"positional join needs equal counts (gold {len(gold)}, preds {len(preds)}); "
+            "or include shape_id+key in each prediction"
+        )
+    return list(zip(gold, preds))
+
+
+def score_rn(pairs: list[tuple[dict, dict]]) -> dict:
+    n = len(pairs)
+    exact = labels_exact = cad_ok = parse_fail = 0
+    chord_hits = chord_total = 0
+    for g, p in pairs:
+        labels, cadence = parse_rn(p.get("prediction") or "")
+        if labels is None:
+            parse_fail += 1
+        gl = g["labels"]
+        l_ok = labels == gl
+        c_ok = cadence == g["cadence"]  # both None counts as correct
+        labels_exact += l_ok
+        cad_ok += c_ok
+        exact += l_ok and c_ok
+        chord_total += len(gl)
+        if labels:
+            chord_hits += sum(a == b for a, b in zip(labels, gl))
+    return {
+        "n": n,
+        "exact": round(exact / n, 4),
+        "labels_exact": round(labels_exact / n, 4),
+        "chord_acc": round(chord_hits / chord_total, 4),
+        "cadence_acc": round(cad_ok / n, 4),
+        "parse_failures": parse_fail,
+    }
+
+
+def score_key(pairs: list[tuple[dict, dict]]) -> dict:
+    n = len(pairs)
+    exact = tonic_ok = mode_ok = parse_fail = 0
+    for g, p in pairs:
+        pred = parse_key(p.get("prediction") or "")
+        if pred is None:
+            parse_fail += 1
+            continue
+        gt, gm = g["target"].rsplit(" ", 1)
+        pt, pm = pred.rsplit(" ", 1)
+        exact += pred == g["target"]
+        tonic_ok += pt == gt
+        mode_ok += pm == gm
+    return {
+        "n": n,
+        "exact": round(exact / n, 4),
+        "tonic_acc": round(tonic_ok / n, 4),
+        "mode_acc": round(mode_ok / n, 4),
+        "parse_failures": parse_fail,
+    }
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("predictions", type=Path)
+    ap.add_argument("--config", choices=["symbol_to_rn", "notes_to_rn", "pcset_to_rn", "key_id"])
+    ap.add_argument("--split", default="test", choices=["train", "validation", "test"])
+    ap.add_argument("--gold", type=Path, help="explicit gold JSONL (overrides --config/--split)")
+    args = ap.parse_args()
+
+    if args.gold:
+        gold_path = args.gold
+        config = args.config or gold_path.parent.name
+    elif args.config:
+        gold_path = REPO_ROOT / "data" / args.config / f"{args.split}.jsonl"
+        config = args.config
+    else:
+        raise SystemExit("need --config or --gold")
+
+    gold = load_jsonl(gold_path)
+    preds = load_jsonl(args.predictions)
+    pairs = join(gold, preds)
+    metrics = score_key(pairs) if config == "key_id" else score_rn(pairs)
+    print(json.dumps({"config": config, "split": args.split, **metrics}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "harmony-dataset"
+version = "0.1.0"
+description = "Synthetic functional-harmony text-to-text dataset: grammar-generated progressions, music21-verified DCML labels"
+readme = "README.md"
+authors = [
+    { name = "4esv", email = "axel@aesv.io" }
+]
+requires-python = ">=3.14"
+dependencies = [
+    "datasets>=5.0.0",
+    "music21>=10.5.0",
+    "pytest>=9.1.1",
+]
+
+[build-system]
+requires = ["uv_build>=0.8.22,<0.9.0"]
+build-backend = "uv_build"

scripts/push_to_hub.py

@@ -0,0 +1,42 @@
+"""Push the dataset repo to the Hub: uv run python scripts/push_to_hub.py
+
+Publishes everything needed to load, audit, and reproduce the dataset.
+BRIEF.md (internal seed notes) stays local.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from huggingface_hub import HfApi
+
+REPO_ID = "4esv/rameau"
+REPO_ROOT = Path(__file__).resolve().parents[1]
+
+IGNORE = [
+    "BRIEF.md",
+    ".git*",
+    ".venv/**",
+    "**/__pycache__/**",
+    ".pytest_cache/**",
+    ".ruff_cache/**",
+    ".DS_Store",
+]
+
+
+def main() -> None:
+    api = HfApi()
+    user = api.whoami()["name"]
+    assert user == REPO_ID.split("/")[0], f"logged in as {user!r}, expected {REPO_ID}"
+    api.create_repo(REPO_ID, repo_type="dataset", exist_ok=True)
+    info = api.upload_folder(
+        repo_id=REPO_ID,
+        repo_type="dataset",
+        folder_path=REPO_ROOT,
+        ignore_patterns=IGNORE,
+        commit_message="Rameau v1: 21,940 records, 4 configs, verified gold, eval harness",
+    )
+    print(f"pushed: https://huggingface.co/datasets/{REPO_ID}\ncommit: {info.oid}")
+
+
+if __name__ == "__main__":
+    main()

src/harmony_dataset/__init__.py

@@ -0,0 +1,14 @@
+"""Synthetic functional-harmony dataset generator.
+
+Grammar-generated chord progressions with constructive DCML Roman-numeral
+labels, verified by a dual-derivation gold gate (music21), framed as multiple
+text-to-text tasks. See export.main() for the entry point.
+"""
+from .vocabulary import Analysis
+from .cadence import classify_cadence
+from .grammar import generate_phrases
+from .generator import build_pool, generate
+from .verify import verify_chord
+
+__all__ = ["Analysis", "classify_cadence", "generate_phrases", "build_pool",
+           "generate", "verify_chord"]

src/harmony_dataset/cadence.py

@@ -0,0 +1,65 @@
+"""Cadence classification into DCML cadence codes.
+
+music21 ships no cadence detector (only building blocks), so this is ours. It
+looks at the last two chords of an Analysis sequence and classifies the terminal
+cadence:
+
+    PAC  perfect authentic   V(7) -> I/i, both root position
+    IAC  imperfect authentic V(7) -> I/i, dominant or tonic inverted
+    HC   half                phrase ends on a root-position diatonic V *triad*
+                             (a terminal V7 demands resolution and is not an HC)
+    PC   plagal              IV/iv -> I/i
+    DC   deceptive           root-position V(7) -> vi/VI (an inverted dominant's
+                             bass must resolve to the tonic, so V65 -> vi is a
+                             voice-leading error, not a deceptive cadence)
+    None no terminal cadence
+
+Simplification: with synthetic root-position chord symbols we have no soprano
+voice, so PAC vs IAC is decided by inversion rather than by melodic closure.
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+from .vocabulary import Analysis
+
+_TONIC = frozenset({"I", "i"})
+_DOMINANT = frozenset({"V"})
+_SUBDOMINANT = frozenset({"IV", "iv"})
+_SUBMEDIANT = frozenset({"vi", "VI"})
+
+# figbass values that denote a root-position chord (triad '' or root seventh '7')
+_ROOT_POSITION = frozenset({"", "7"})
+
+
+def _is_diatonic(a: Analysis) -> bool:
+    return a.relativeroot is None
+
+
+def _is_root_position(a: Analysis) -> bool:
+    return a.figbass in _ROOT_POSITION
+
+
+def _is(a: Analysis, degrees: frozenset[str]) -> bool:
+    return _is_diatonic(a) and a.numeral in degrees
+
+
+def classify_cadence(seq: list[Analysis]) -> Optional[str]:
+    if len(seq) < 2:
+        return None
+    penult, last = seq[-2], seq[-1]
+
+    if _is(last, _TONIC):
+        if _is(penult, _DOMINANT):
+            return "PAC" if _is_root_position(penult) and _is_root_position(last) else "IAC"
+        if _is(penult, _SUBDOMINANT):
+            return "PC"
+        return None
+
+    if _is(last, _SUBMEDIANT) and _is(penult, _DOMINANT) and _is_root_position(penult):
+        return "DC"
+
+    if _is(last, _DOMINANT) and last.figbass == "":
+        return "HC"
+
+    return None

src/harmony_dataset/export.py

@@ -0,0 +1,301 @@
+"""Assemble the dataset on disk: one config per task, three splits each, plus a
+draft dataset card and a verification report.
+
+Run: ``uv run python -m harmony_dataset.export``. Nothing here pushes to the Hub.
+"""
+from __future__ import annotations
+
+import json
+from collections import Counter, defaultdict
+from pathlib import Path
+
+from . import tasks
+from .generator import GenResult, generate
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+DATA_DIR = REPO_ROOT / "data"
+SPLITS = ("train", "validation", "test")
+DEFAULT_CONFIG = "notes_to_rn"
+
+TASK_BLURB = {
+    "symbol_to_rn": "key + chord symbols -> Roman numerals + cadence (easy: chord quality is given)",
+    "notes_to_rn": "key + spelled notes -> Roman numerals + cadence (must read each chord)",
+    "pcset_to_rn": "key + bass-first pitch-class lists -> Roman numerals + cadence (no spelling)",
+    "key_id": "spelled notes, no key -> identify the key (only key-unambiguous phrases)",
+}
+CADENCE_GLOSS = {
+    "PAC": "perfect authentic", "IAC": "imperfect authentic", "HC": "half",
+    "DC": "deceptive", "PC": "plagal",
+}
+
+
+def bucket(res: GenResult) -> dict[tuple[str, str], list[dict]]:
+    out: dict[tuple[str, str], list[dict]] = defaultdict(list)
+    for r in res.records:
+        out[(r.data["task"], r.split)].append(r.data)
+    # stable order within each file
+    for recs in out.values():
+        recs.sort(key=lambda d: (d["shape_id"], d["key"]))
+    return out
+
+
+def write_jsonl(records: list[dict], path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as fh:
+        for d in records:
+            fh.write(json.dumps(d, ensure_ascii=False) + "\n")
+
+
+def _configs_yaml() -> str:
+    lines = ["configs:"]
+    for task in tasks.TASKS:
+        lines.append(f"  - config_name: {task}")
+        if task == DEFAULT_CONFIG:
+            lines.append("    default: true")
+        lines.append("    data_files:")
+        for split in SPLITS:
+            lines.append(f"      - split: {split}")
+            lines.append(f"        path: data/{task}/{split}.jsonl")
+    return "\n".join(lines)
+
+
+def render_card(res: GenResult, buckets: dict) -> str:
+    total = len(res.records)
+    per_task = Counter(r.data["task"] for r in res.records)
+    per_split = Counter(r.split for r in res.records)
+    size_cat = "10K<n<100K" if 10_000 <= total < 100_000 else "1K<n<10K" if total >= 1_000 else "n<1K"
+    task_rows = "\n".join(
+        f"| `{t}` | {TASK_BLURB[t]} | {per_task[t]} |" for t in tasks.TASKS
+    )
+    return f"""---
+pretty_name: "Rameau: Functional Harmony from Notation (Roman Numerals, Cadence, Key)"
+license: cc-by-4.0
+language:
+  - en
+task_categories:
+  - text2text-generation
+tags:
+  - music
+  - music-theory
+  - functional-harmony
+  - roman-numeral-analysis
+  - chord-progression
+  - cadence
+  - key-detection
+  - benchmark
+  - synthetic
+size_categories:
+  - {size_cat}
+annotations_creators:
+  - machine-generated
+source_datasets:
+  - original
+{_configs_yaml()}
+---
+
+# Rameau: functional harmony from notation
+
+A **text-to-text** dataset and benchmark for functional-harmony understanding in
+music notation: Roman-numeral analysis, cadence classification, and key
+identification. Progressions are generated by a probabilistic common-practice
+grammar and framed as four tasks of increasing difficulty — the harder tasks
+**hide the answer**, so the data tests harmonic reasoning, not chord-symbol lookup.
+
+Named for Jean-Philippe Rameau, whose *Traité de l'harmonie* (1722) founded the
+theory of functional harmony this dataset teaches.
+
+```
+symbol_to_rn  key: C major / progression: Dm7 G7 Cmaj7   ->  ii7 V7 IM7 / cadence: PAC
+notes_to_rn   key: C major / notes: D4 F4 A4 C5 | ...     ->  ii7 V7 IM7 / cadence: PAC
+pcset_to_rn   key: C major / pitch classes: [2 5 9 0]|... ->  ii7 V7 IM7 / cadence: PAC
+key_id        notes: D4 F4 A4 C5 | G3 B3 D4 F4 | ...      ->  C major
+```
+
+## Configs (tasks)
+
+Load one with `load_dataset("4esv/rameau", "<config>")`. Default: `{DEFAULT_CONFIG}`.
+
+| config | task | rows |
+|---|---|---|
+{task_rows}
+| | **total** | **{total}** |
+
+## How the gold labels are generated (and why they are trustworthy)
+
+Labels are **not hand-annotated**. A probabilistic functional grammar
+(tonic -> predominant -> dominant -> cadence, with sevenths, inversions,
+cadential 6-4s and secondary dominants) generates each progression *together with*
+its intended Roman-numeral analysis. Every chord is then checked two independent
+ways with [`music21`](https://web.mit.edu/music21/):
+
+- the Roman-numeral label rendered to pitch classes by the roman engine;
+- the printed chord symbol parsed to pitch classes by the chord-symbol parser;
+
+and the item is kept only if the two agree on pitch content **and** bass. On this
+release: **{res.chord_agreement_rate:.2%}** chord-level agreement
+({res.attempted_chords - len(res.failures)}/{res.attempted_chords} chords;
+{res.instances - res.dropped_instances}/{res.instances} instances kept). See `VERIFY.md`.
+
+Built from **{res.shapes} distinct progression shapes** (key-independent), transposed
+across keys. All content is synthetic; no third-party corpus is redistributed.
+
+## Label convention
+
+Roman numerals follow the **DCML harmony standard**'s feature decomposition
+(`numeral` / `form` / `figbass` / `changes` / `relativeroot`), spec at
+<https://github.com/DCMLab/standards> — we conform to the notation, we do not copy
+DCML data. Major-seventh tonic is `IM7`; secondary dominants use `/` (e.g. `V7/vi`).
+Cadence codes: {", ".join(f"`{k}` {v}" for k, v in CADENCE_GLOSS.items())}.
+
+## Fields
+
+Common to every config: `input`, `target`, `key`, `mode`, `labels`, `cadence`,
+`analysis` (per-chord DCML features), `source` (`grammar`/`curated`/`single`),
+`category`, `shape_id`. Plus the input representation for the config: `chords`
+(symbols), `notes` (spelled, bass-first), or `pitch_classes` (bass-first).
+
+Accidentals are written the standard way (`Bb`, `F#`, `Cb`). Note for music21
+users: its parsers want `-` for flats — convert `b -> -` in note/root names
+before calling `ChordSymbol` or `Pitch`.
+
+## Splits (leakage-free; test doubles as a benchmark)
+
+The atomic unit is a **shape** (a key-independent Roman-numeral sequence). Each
+shape is hashed to exactly one split, so a shape — and all of its transpositions
+**and all of its task framings** — never crosses splits. Split sizes (rows):
+train {per_split['train']} / validation {per_split['validation']} / test {per_split['test']}.
+
+## Known limitations
+
+- **Synthetic distribution.** Grammar-generated common-practice progressions, not
+  sampled from real repertoire; the chord distribution is not naturalistic.
+- **PAC vs IAC** is decided by inversion (no notated soprano voice). Cadence rules
+  are strict: an HC must end on a root-position V *triad* (a terminal V7 is not
+  labelled), and a DC requires a root-position dominant (`V65 -> vi` is not one).
+- **key_id** includes only cadence-terminated progressions of >= 3 chords whose
+  notes contain both key-defining degrees (scale degree 4 and the leading tone),
+  so the key is uniquely determined. Without this gate, gold labels can be
+  contestable — e.g. `I V7/V V` in C is note-identical to `IV V7 I` in G, and the
+  G-major reading (a PAC) is arguably stronger. Such phrases are excluded.
+- Harmony only — no voice-leading, melody, or rhythm. No modal mixture / Neapolitan
+  / augmented sixths yet.
+
+## Evaluation
+
+The `test` split is a benchmark: gold is deterministic, so scoring is **exact
+match — no LLM judge**. The repo ships a self-contained harness under `eval/`:
+
+```bash
+# query any OpenAI-compatible endpoint (ollama, vLLM, OpenAI, ...):
+python eval/run_model.py --config notes_to_rn --model <model> --out preds.jsonl
+# score predictions (stdlib only):
+python eval/score.py preds.jsonl --config notes_to_rn --split test
+```
+
+Metrics: `exact` (Roman numerals **and** cadence correct — the headline number),
+`labels_exact`, `chord_acc` (positional), `cadence_acc`; for `key_id`: `exact`,
+`tonic_acc`, `mode_acc`. The zero-shot prompts are versioned in
+`eval/prompts.py`; parsing rules are documented in `eval/README.md`.
+
+## Reproduce
+
+The full generation pipeline ships in this repo (`src/harmony_dataset/`):
+
+```bash
+uv sync && uv run pytest                   # full suite, incl. the eval harness
+uv run python -m harmony_dataset.export    # regenerates data/, README, VERIFY.md
+```
+
+## Licensing
+
+**CC-BY-4.0.** Content is generated by this repository's pipeline from music theory;
+the underlying facts are not copyrightable and no source corpus is redistributed.
+
+## Citation
+
+```
+@misc{{rameau,
+  title  = {{Rameau: Functional Harmony from Notation (Roman Numerals, Cadence, Key)}},
+  author = {{Stevens, Axel}},
+  year   = {{2026}},
+  url    = {{https://huggingface.co/datasets/4esv/rameau}},
+  note   = {{Synthetic, grammar-generated, music21-verified, DCML-convention labels}}
+}}
+```
+"""
+
+
+def render_verify(res: GenResult) -> str:
+    L: list[str] = ["# Verification report\n", "## Gold gate (dual-derivation agreement)\n",
+                    "| metric | value |", "|---|---|",
+                    f"| distinct shapes | {res.shapes} |",
+                    f"| instances (shape x key) | {res.instances} |",
+                    f"| instances dropped | {res.dropped_instances} |",
+                    f"| chords attempted | {res.attempted_chords} |",
+                    f"| chord disagreements | {len(res.failures)} |",
+                    f"| **chord agreement rate** | **{res.chord_agreement_rate:.3%}** |",
+                    f"| total records | {len(res.records)} |\n"]
+
+    per_source = Counter(r.data["source"] for r in res.records)
+    per_cadence = Counter(r.data["cadence"] for r in res.records)
+    L += ["## Distribution\n", f"- by source: {dict(per_source)}",
+          f"- by cadence: {dict(per_cadence)}\n"]
+
+    if res.failures:
+        L += ["## Dropped chords\n", "| shape | key | figure | symbol | reason |", "|---|---|---|---|---|"]
+        for f in res.failures[:50]:
+            c = f.check
+            L.append(f"| {f.shape_id} | {f.key} | `{c.figure}` | `{c.symbol}` | {c.reason} |")
+        L.append("")
+
+    # the brief example across all four task framings
+    L.append("## Same progression, four framings (brief example in C major)\n")
+    brief = [r.data for r in res.records
+             if r.data["shape_id"] == _shape_id_of(res, ["ii7", "V7", "IM7"])
+             and r.data["key"] == "C major"]
+    for d in sorted(brief, key=lambda d: tasks.TASKS.index(d["task"])):
+        L.append(f"- **{d['task']}**")
+        L.append(f"  - in:  `{d['input'].replace(chr(10), '  //  ')}`")
+        L.append(f"  - out: `{d['target'].replace(chr(10), '  //  ')}`")
+    L.append("")
+
+    # a spread of grammar phrases (notes_to_rn framing, reference key)
+    L.append("## Grammar phrases (notes_to_rn, in C major / A minor)\n")
+    shown = 0
+    for r in sorted(res.records, key=lambda r: r.data["shape_id"]):
+        d = r.data
+        if d["task"] != "notes_to_rn" or d["source"] != "grammar":
+            continue
+        if d["key"] not in ("C major", "A minor"):
+            continue
+        cad = d["cadence"] or "-"
+        L.append(f"- `{d['key']}`  {d['input'].split('notes: ')[1]}")
+        L.append(f"  -> `{' '.join(d['labels'])}` ({cad})")
+        shown += 1
+        if shown >= 12:
+            break
+    L.append("")
+    return "\n".join(L)
+
+
+def _shape_id_of(res: GenResult, labels: list[str]) -> str:
+    for r in res.records:
+        if r.data["labels"] == labels:
+            return r.data["shape_id"]
+    return ""
+
+
+def main(out_dir: Path = REPO_ROOT) -> GenResult:
+    res = generate()
+    buckets = bucket(res)
+    for (task, split), recs in buckets.items():
+        write_jsonl(recs, out_dir / "data" / task / f"{split}.jsonl")
+    (out_dir / "README.md").write_text(render_card(res, buckets), encoding="utf-8")
+    (out_dir / "VERIFY.md").write_text(render_verify(res), encoding="utf-8")
+    print(f"wrote {len(res.records)} records across {len(tasks.TASKS)} configs "
+          f"from {res.shapes} shapes; chord agreement {res.chord_agreement_rate:.3%}")
+    return res
+
+
+if __name__ == "__main__":
+    main()

src/harmony_dataset/generator.py

@@ -0,0 +1,212 @@
+"""Build the full dataset: a pool of distinct progression shapes (curated anchors
++ grammar-generated phrases), transposed across keys, gold-gated, and framed as
+multiple tasks.
+
+Leakage control: the atomic unit is a **shape** — a key-independent tuple of
+Roman-numeral labels. Each shape is hashed to exactly one split, so no shape (and
+none of its transpositions, and none of its task framings) ever crosses splits.
+The hash is stable (sha1), so splits are reproducible.
+"""
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass, field
+from functools import lru_cache
+from typing import Optional
+
+from music21 import key
+
+from . import tasks
+from .cadence import classify_cadence
+from .grammar import generate_phrases
+from .vocabulary import (
+    Analysis,
+    MAJOR_KEYS,
+    MINOR_KEYS,
+    bass_first_pcs_from_figure,
+    chord_symbol_from_figure,
+    spelled_notes_from_figure,
+)
+from .verify import ChordCheck, verify_chord
+
+# how many grammar phrases to draw per mode, and how many keys to transpose a
+# multi-chord shape into (single chords always go to all 12).
+N_PHRASES_PER_MODE = 400
+KEYS_PER_SHAPE = 6
+SEED = 20260709
+
+
+def _spec(*s: str) -> tuple[Analysis, ...]:
+    return tuple(Analysis.parse(x) for x in s)
+
+
+# Curated anchors: pedagogically important progressions worth guaranteeing.
+_CURATED: list[tuple[str, str, tuple[Analysis, ...]]] = [
+    ("major", "cadence", _spec("ii7", "V7", "IM7")),      # the brief's jazz ii-V-I
+    ("major", "cadence", _spec("ii7", "V7", "I")),
+    ("major", "common", _spec("I", "IV", "V", "I")),
+    ("major", "common", _spec("I", "vi", "IV", "V")),
+    ("major", "common", _spec("I", "V", "vi", "IV")),
+    ("major", "secondary", _spec("I", "V7/vi", "vi", "ii7", "V7", "I")),
+    ("minor", "common", _spec("i", "VII", "VI", "V")),    # Andalusian
+    ("minor", "cadence", _spec("iio6", "V7", "i")),
+    ("minor", "common", _spec("i", "iv", "V", "i")),
+]
+
+# Single-chord vocabulary coverage (length-1 shapes).
+_SINGLE_MAJOR = ["I", "ii", "iii", "IV", "V", "vi", "viio",
+                 "IM7", "ii7", "iii7", "IVM7", "V7", "vi7", "vii%7",
+                 "I6", "I64", "V6", "V65", "V43", "V2", "ii6"]
+_SINGLE_MINOR = ["i", "iio", "III", "iv", "V", "VI", "viio",
+                 "i7", "ii%7", "iv7", "V7", "VIM7", "viio7",
+                 "i6", "i64", "V6", "V65", "V43", "iio6"]
+
+
+@dataclass(frozen=True)
+class Shape:
+    mode: str
+    category: str
+    source: str            # 'curated' | 'grammar' | 'single'
+    analyses: tuple[Analysis, ...]
+
+    @property
+    def labels(self) -> tuple[str, ...]:
+        return tuple(a.dcml_label() for a in self.analyses)
+
+    @property
+    def shape_id(self) -> str:
+        raw = f"{self.mode}|{','.join(self.labels)}"
+        return hashlib.sha1(raw.encode()).hexdigest()[:10]
+
+    @property
+    def split(self) -> str:
+        bucket = int(self.shape_id, 16) % 100
+        return "train" if bucket < 70 else "validation" if bucket < 85 else "test"
+
+
+@lru_cache(maxsize=1)
+def build_pool() -> list[Shape]:
+    """Distinct shapes: curated anchors, single chords, grammar phrases. Deduped."""
+    pool: list[Shape] = []
+    seen: set[tuple[str, tuple[str, ...]]] = set()
+
+    def add(shape: Shape) -> None:
+        k = (shape.mode, shape.labels)
+        if k not in seen:
+            seen.add(k)
+            pool.append(shape)
+
+    for mode, cat, analyses in _CURATED:
+        add(Shape(mode, cat, "curated", analyses))
+    for spec in _SINGLE_MAJOR:
+        add(Shape("major", "single", "single", _spec(spec)))
+    for spec in _SINGLE_MINOR:
+        add(Shape("minor", "single", "single", _spec(spec)))
+    for mode in ("major", "minor"):
+        for phrase in generate_phrases(mode, N_PHRASES_PER_MODE, seed=SEED):
+            add(Shape(mode, "phrase", "grammar", tuple(phrase)))
+    return pool
+
+
+def _keys_for(shape: Shape) -> list[str]:
+    keys = MAJOR_KEYS if shape.mode == "major" else MINOR_KEYS
+    if len(shape.analyses) == 1:
+        return keys
+    # always include the reference key (C major / A minor) so canonical shapes
+    # appear in their home key, then a hash-spread sample of others.
+    ref = "C" if shape.mode == "major" else "a"
+    offset = int(shape.shape_id, 16) % 12
+    idxs = sorted({(offset + i * 5) % 12 for i in range(KEYS_PER_SHAPE)})
+    ordered = [ref] + [keys[i] for i in idxs if keys[i] != ref]
+    return ordered
+
+
+@dataclass(frozen=True)
+class Record:
+    data: dict
+    split: str
+
+
+@dataclass
+class Failure:
+    shape_id: str
+    key: str
+    check: ChordCheck
+
+
+@dataclass
+class GenResult:
+    records: list[Record] = field(default_factory=list)
+    failures: list[Failure] = field(default_factory=list)
+    shapes: int = 0
+    instances: int = 0
+    dropped_instances: int = 0
+    attempted_chords: int = 0
+
+    @property
+    def chord_agreement_rate(self) -> float:
+        if self.attempted_chords == 0:
+            return 1.0
+        return (self.attempted_chords - len(self.failures)) / self.attempted_chords
+
+
+def _instantiate(shape: Shape, key_name: str) -> Optional[dict]:
+    """Render a shape in a key and gold-gate it. Returns representation data or None."""
+    K = key.Key(key_name)
+    symbols, notes, pcs, checks = [], [], [], []
+    for a in shape.analyses:
+        fig = a.music21_figure()
+        sym = chord_symbol_from_figure(fig, K)
+        checks.append(verify_chord(a, sym, K))
+        symbols.append(sym.replace("-", "b"))
+        notes.append(spelled_notes_from_figure(fig, K))
+        pcs.append(bass_first_pcs_from_figure(fig, K))
+    if not all(c.ok for c in checks):
+        return {"_failed": [c for c in checks if not c.ok]}
+    return {
+        "key": f"{K.tonic.name.replace('-', 'b')} {K.mode}",
+        "symbols": symbols, "notes": notes, "pcs": pcs,
+    }
+
+
+@lru_cache(maxsize=1)
+def generate() -> GenResult:
+    res = GenResult()
+    pool = build_pool()
+    res.shapes = len(pool)
+    for shape in pool:
+        labels = list(shape.labels)
+        cadence = classify_cadence(list(shape.analyses))
+        analysis_dicts = [a.to_dict() for a in shape.analyses]
+        for key_name in _keys_for(shape):
+            res.instances += 1
+            res.attempted_chords += len(shape.analyses)
+            data = _instantiate(shape, key_name)
+            if data is None or "_failed" in data:
+                res.dropped_instances += 1
+                for c in (data or {}).get("_failed", []):
+                    res.failures.append(Failure(shape.shape_id, key_name, c))
+                continue
+            for task in tasks.TASKS:
+                r = tasks.render(
+                    task, key=data["key"], symbols=data["symbols"],
+                    notes=data["notes"], pcs=data["pcs"], labels=labels, cadence=cadence,
+                )
+                if r is None:
+                    continue
+                record = {
+                    "task": r.task,
+                    "input": r.input,
+                    "target": r.target,
+                    "key": data["key"],
+                    "mode": shape.mode,
+                    "labels": labels,
+                    "cadence": cadence,
+                    "analysis": analysis_dicts,
+                    "source": shape.source,
+                    "category": shape.category,
+                    "shape_id": shape.shape_id,
+                    **r.extra,
+                }
+                res.records.append(Record(record, shape.split))
+    return res

src/harmony_dataset/grammar.py

@@ -0,0 +1,114 @@
+"""A probabilistic functional-harmony grammar.
+
+Rather than a fixed list of textbook progressions, this assembles phrases from
+functional zones — opening (tonic) -> predominant -> dominant -> cadence — with
+weighted choices at each step, plus sevenths, inversions, cadential 6-4s, and
+secondary dominants. It is a Markov-style generative grammar constrained to
+common-practice syntax, so every phrase is musically shaped, cadence-terminated
+(key-pinning), and — by construction — labelled correctly.
+
+All chord specs are drawn from a set pre-verified against the gold gate, so the
+grammar never emits a chord whose Roman-numeral label disagrees with its pitches.
+Deterministic under a seed.
+"""
+from __future__ import annotations
+
+import random
+from typing import Optional
+
+from .vocabulary import Analysis
+
+# Each option is (list-of-specs, weight). Specs are compact DCML labels parsed by
+# Analysis.parse. An empty predominant list yields direct I-V-I motion.
+_CONFIG = {
+    "major": {
+        "tonic": "I",
+        "submediant": "vi",
+        "openings": [
+            (["I"], 6), (["I", "I6"], 1), (["I", "vi"], 2),
+            (["I", "iii", "vi"], 1), (["I", "V6", "I"], 1), (["I6"], 1),
+        ],
+        "predominants": [
+            ([], 2), (["IV"], 4), (["ii"], 3), (["ii7"], 3), (["ii6"], 2), (["ii65"], 2),
+            (["IV", "ii6"], 1), (["vi", "ii7"], 1), (["vi", "IV"], 1), (["I6", "IV"], 1),
+            (["V7/V"], 1), (["V7/ii", "ii7"], 1), (["V7/IV", "IV"], 1), (["V7/vi", "vi", "ii7"], 1),
+        ],
+        "dominants": [
+            (["V"], 2), (["V7"], 4), (["V65"], 1), (["I64", "V7"], 2), (["I64", "V"], 1),
+            (["viio6", "V7"], 1), (["V7/V", "V7"], 1),
+        ],
+        # half cadences end on a V *triad*; deceptive resolutions need the
+        # dominant in root position (see cadence.py) — hence the separate lists.
+        "dominants_half": [(["V"], 4), (["I64", "V"], 2), (["V7/V", "V"], 1)],
+        "dominants_deceptive": [(["V7"], 4), (["V"], 2), (["I64", "V7"], 2), (["viio6", "V7"], 1)],
+        "plagal_predominants": [(["IV"], 3), (["ii6", "IV"], 1), (["I6", "IV"], 1)],
+        "resolutions": [(["I"], 6), (["I6"], 1)],
+    },
+    "minor": {
+        "tonic": "i",
+        "submediant": "VI",
+        "openings": [
+            (["i"], 6), (["i", "i6"], 1), (["i", "VI"], 2), (["i", "III"], 1), (["i6"], 1),
+        ],
+        "predominants": [
+            ([], 2), (["iv"], 4), (["iio6"], 3), (["ii%7"], 2), (["iv6"], 2),
+            (["VI", "iv"], 1), (["iv", "iio6"], 1), (["III", "iv"], 1),
+            (["V7/V"], 1), (["V7/iv", "iv"], 1), (["V7/VI", "VI", "iio6"], 1),
+        ],
+        "dominants": [
+            (["V"], 2), (["V7"], 4), (["V65"], 1), (["i64", "V7"], 2), (["i64", "V"], 1),
+            (["viio6", "V7"], 1), (["V7/V", "V7"], 1),
+        ],
+        "dominants_half": [(["V"], 4), (["i64", "V"], 2), (["V7/V", "V"], 1)],
+        "dominants_deceptive": [(["V7"], 4), (["V"], 2), (["i64", "V7"], 2), (["viio6", "V7"], 1)],
+        "plagal_predominants": [(["iv"], 3), (["iio6", "iv"], 1), (["VI", "iv"], 1)],
+        "resolutions": [(["i"], 6), (["i6"], 1)],
+    },
+}
+
+_KINDS = [("authentic", 5), ("half", 2), ("deceptive", 2), ("plagal", 1)]
+
+
+def _pick(rng: random.Random, options: list[tuple[list, int]]) -> list:
+    seqs = [o for o, _ in options]
+    weights = [w for _, w in options]
+    return list(rng.choices(seqs, weights=weights, k=1)[0])
+
+
+def _assemble(cfg: dict, rng: random.Random) -> list[str]:
+    kind = rng.choices([k for k, _ in _KINDS], weights=[w for _, w in _KINDS], k=1)[0]
+    specs = _pick(rng, cfg["openings"])
+    if kind == "plagal":
+        specs += _pick(rng, cfg["plagal_predominants"])
+        specs += [cfg["tonic"]]
+    else:
+        specs += _pick(rng, cfg["predominants"])
+        if kind == "half":
+            specs += _pick(rng, cfg["dominants_half"])
+        elif kind == "deceptive":
+            specs += _pick(rng, cfg["dominants_deceptive"])
+            specs += [cfg["submediant"]]
+        else:
+            specs += _pick(rng, cfg["dominants"])
+            specs += _pick(rng, cfg["resolutions"])
+    return specs
+
+
+def generate_phrases(mode: str, n: int, seed: int = 0) -> list[list[Analysis]]:
+    """Return up to ``n`` distinct, cadence-terminated phrases for the mode."""
+    cfg = _CONFIG[mode]
+    rng = random.Random(seed)
+    out: list[list[Analysis]] = []
+    seen: set[tuple[str, ...]] = set()
+    cap = max(500, n * 80)
+    for _ in range(cap):
+        if len(out) >= n:
+            break
+        specs = _assemble(cfg, rng)
+        phrase = [Analysis.parse(s) for s in specs]
+        key_ = tuple(a.dcml_label() for a in phrase)
+        if key_ in seen:
+            continue
+        seen.add(key_)
+        out.append(phrase)
+    return out

src/harmony_dataset/tasks.py

@@ -0,0 +1,103 @@
+"""The task tiers — the same verified progression framed several ways.
+
+The point is to *hide the answer* to varying degrees so the dataset trains and
+tests real harmonic reasoning, not chord-symbol lookup:
+
+    symbol_to_rn  key + chord symbols        -> RN + cadence   (easy; quality given)
+    notes_to_rn   key + spelled notes        -> RN + cadence   (must read the chord)
+    pcset_to_rn   key + bass-first pc lists   -> RN + cadence   (no spelling either)
+    key_id        spelled notes (no key)     -> key            (infer the key)
+
+Each is exposed as its own dataset config so a consumer can load exactly the tier
+they want.
+
+``key_id`` is determinacy-gated. A cadence and length alone do not pin a key:
+``I V7/V V`` in C is note-identical to ``IV V7 I`` in G — a *stronger* reading —
+so its gold label would be contestable. We therefore require the phrase's notes
+to contain both key-defining degrees, scale degree 4 and the leading tone: that
+tritone occurs in exactly one major diatonic collection, and the tonic-chord
+third (present via the cadence/opening) settles major vs minor. Phrases failing
+the gate are simply excluded from key_id (they remain in the other tasks, where
+the key is given).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+TASKS = ("symbol_to_rn", "notes_to_rn", "pcset_to_rn", "key_id")
+
+# key_id needs enough context to pin a key: a real cadence and >= 3 chords.
+_KEY_ID_MIN_CHORDS = 3
+
+_LETTER_PC = {"C": 0, "D": 2, "E": 4, "F": 5, "G": 7, "A": 9, "B": 11}
+
+
+def _tonic_pc(key_str: str) -> int:
+    """Pitch class of the tonic in a key string like 'Ab major' or 'F# minor'."""
+    name = key_str.split()[0]
+    pc = _LETTER_PC[name[0]]
+    for ch in name[1:]:
+        pc += 1 if ch == "#" else -1
+    return pc % 12
+
+
+def _key_is_determined(key: str, pcs: list[list[int]]) -> bool:
+    """True when the notes contain scale degree 4 AND the leading tone."""
+    tonic = _tonic_pc(key)
+    present = {p for chord_pcs in pcs for p in chord_pcs}
+    return {(tonic + 5) % 12, (tonic + 11) % 12} <= present
+
+
+@dataclass(frozen=True)
+class Rendered:
+    task: str
+    input: str
+    target: str
+    extra: dict  # the input-side representation, for transparency
+
+
+def _rn_target(labels: list[str], cadence: Optional[str]) -> str:
+    body = " ".join(labels)
+    return f"{body}\ncadence: {cadence}" if cadence else body
+
+
+def _notes_str(notes: list[list[str]]) -> str:
+    return " | ".join(" ".join(ch) for ch in notes)
+
+
+def _pcs_str(pcs: list[list[int]]) -> str:
+    return " | ".join("[" + " ".join(str(p) for p in ch) + "]" for ch in pcs)
+
+
+def render(
+    task: str,
+    *,
+    key: str,
+    symbols: list[str],
+    notes: list[list[str]],
+    pcs: list[list[int]],
+    labels: list[str],
+    cadence: Optional[str],
+) -> Optional[Rendered]:
+    """Render one task, or return None when the task does not apply to this item."""
+    if task == "symbol_to_rn":
+        return Rendered(task, f"key: {key}\nprogression: {' '.join(symbols)}",
+                        _rn_target(labels, cadence), {"chords": symbols})
+
+    if task == "notes_to_rn":
+        return Rendered(task, f"key: {key}\nnotes: {_notes_str(notes)}",
+                        _rn_target(labels, cadence), {"notes": notes})
+
+    if task == "pcset_to_rn":
+        return Rendered(task, f"key: {key}\npitch classes: {_pcs_str(pcs)}",
+                        _rn_target(labels, cadence), {"pitch_classes": pcs})
+
+    if task == "key_id":
+        if cadence is None or len(labels) < _KEY_ID_MIN_CHORDS:
+            return None
+        if not _key_is_determined(key, pcs):
+            return None
+        return Rendered(task, f"notes: {_notes_str(notes)}", key, {"notes": notes})
+
+    raise ValueError(f"unknown task {task!r}")

src/harmony_dataset/verify.py

@@ -0,0 +1,61 @@
+"""The gold gate: dual-derivation verification.
+
+For each chord we derive pitch content two independent ways and require they
+agree exactly (pitch-class set + bass):
+
+    figure  -> music21 roman engine   -> pitches      (the label's meaning)
+    symbol  -> music21 chord-symbol parser -> pitches  (what the model sees)
+
+If they disagree, the Roman-numeral label and the printed chord symbol denote
+different chords, so the training pair would be wrong. Such items are dropped
+and surfaced in the verification report. This is what makes the synthetic gold
+trustworthy without hand-labelling.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from music21 import key
+
+from .vocabulary import (
+    Analysis,
+    bass_pc_from_figure,
+    bass_pc_from_symbol,
+    pitch_classes_from_figure,
+    pitch_classes_from_symbol,
+)
+
+# music21 returns this string when it cannot name a chord.
+_UNIDENTIFIED = "Chord Symbol Cannot Be Identified"
+
+
+@dataclass(frozen=True)
+class ChordCheck:
+    ok: bool
+    figure: str
+    symbol: str
+    figure_pcs: frozenset[int]
+    symbol_pcs: frozenset[int]
+    reason: str = ""
+
+
+def verify_chord(analysis: Analysis, symbol: str, key_obj: key.Key) -> ChordCheck:
+    figure = analysis.music21_figure()
+    fig_pcs = pitch_classes_from_figure(figure, key_obj)
+
+    if not symbol or symbol == _UNIDENTIFIED:
+        return ChordCheck(False, figure, symbol, fig_pcs, frozenset(), "unidentified chord symbol")
+
+    try:
+        sym_pcs = pitch_classes_from_symbol(symbol)
+        sym_bass = bass_pc_from_symbol(symbol)
+    except Exception as exc:  # music21 raises a variety of parse errors
+        return ChordCheck(False, figure, symbol, fig_pcs, frozenset(), f"symbol parse error: {exc}")
+
+    if fig_pcs != sym_pcs:
+        return ChordCheck(False, figure, symbol, fig_pcs, sym_pcs, "pitch-class set mismatch")
+
+    if bass_pc_from_figure(figure, key_obj) != sym_bass:
+        return ChordCheck(False, figure, symbol, fig_pcs, sym_pcs, "bass mismatch (inversion)")
+
+    return ChordCheck(True, figure, symbol, fig_pcs, sym_pcs)

src/harmony_dataset/vocabulary.py

@@ -0,0 +1,163 @@
+"""DCML label grammar and the music21 bridge.
+
+The dataset's canonical harmony convention is the DCML feature decomposition
+(``numeral / form / figbass / changes / relativeroot``) — see the spec at
+github.com/DCMLab/standards. We *conform* to that notation; we do not copy any
+DCML data, which keeps the generated dataset cleanly CC-BY-4.0.
+
+music21 is the engine. Its figure strings match DCML almost exactly for the
+vocabulary we generate; the one divergence is the half-diminished glyph
+(DCML ``%`` vs music21 ``ø``). All pitch reasoning goes through music21 so the
+verification gate (``verify.py``) can cross-check labels against chord symbols.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import Optional
+
+from music21 import chord, harmony, key, roman
+
+# DCML form glyph -> music21 form glyph. Only '%' differs.
+_FORM_DCML_TO_M21 = {"": "", "o": "o", "+": "+", "%": "ø", "M": "M"}
+VALID_FORMS = frozenset(_FORM_DCML_TO_M21)
+VALID_FIGBASS = frozenset({"", "6", "64", "7", "65", "43", "2"})
+
+
+@dataclass(frozen=True)
+class Analysis:
+    """One chord's functional analysis in the DCML feature decomposition.
+
+    ``numeral`` carries triad quality in its case (upper = major third, lower =
+    minor third) and may carry an accidental prefix (e.g. ``bII``, ``#iv``).
+    """
+
+    numeral: str
+    form: str = ""
+    figbass: str = ""
+    changes: str = ""
+    relativeroot: Optional[str] = None
+
+    def __post_init__(self) -> None:
+        if self.form not in VALID_FORMS:
+            raise ValueError(f"invalid DCML form {self.form!r}")
+        if self.figbass not in VALID_FIGBASS:
+            raise ValueError(f"invalid figbass {self.figbass!r}")
+
+    def dcml_label(self) -> str:
+        """The canonical DCML label string, e.g. ``ii7``, ``IM7``, ``ii%65``, ``V7/V``."""
+        base = f"{self.numeral}{self.form}{self.figbass}{self.changes}"
+        return f"{base}/{self.relativeroot}" if self.relativeroot else base
+
+    def music21_figure(self) -> str:
+        """The equivalent music21 RomanNumeral figure (``%`` -> ``ø``)."""
+        base = f"{self.numeral}{_FORM_DCML_TO_M21[self.form]}{self.figbass}{self.changes}"
+        return f"{base}/{self.relativeroot}" if self.relativeroot else base
+
+    def to_dict(self) -> dict:
+        return {
+            "numeral": self.numeral,
+            "form": self.form,
+            "figbass": self.figbass,
+            "changes": self.changes,
+            "relativeroot": self.relativeroot,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "Analysis":
+        return cls(
+            numeral=d["numeral"],
+            form=d.get("form", ""),
+            figbass=d.get("figbass", ""),
+            changes=d.get("changes", ""),
+            relativeroot=d.get("relativeroot"),
+        )
+
+    @classmethod
+    def parse(cls, spec: str) -> "Analysis":
+        """Parse a compact DCML spec, e.g. ``ii7``, ``IM7``, ``iio6``, ``ii%65``, ``V7/V``."""
+        m = _SPEC_RE.match(spec)
+        if not m:
+            raise ValueError(f"bad chord spec {spec!r}")
+        numeral, form, figbass, rel = m.groups()
+        return cls(numeral=numeral, form=form or "", figbass=figbass or "", relativeroot=rel)
+
+
+# accidentals + roman numeral, optional form glyph, optional figbass, optional /relativeroot
+_SPEC_RE = re.compile(r"^([b#]*[iIvV]+)([o+%M]?)(\d*)(?:/(.+))?$")
+
+
+# ---------------------------------------------------------------------------
+# music21 bridge. Cached because RomanNumeral / ChordSymbol construction is the
+# hot path when transposing hundreds of templates across 24 keys.
+# ---------------------------------------------------------------------------
+
+
+@lru_cache(maxsize=None)
+def _roman(figure: str, key_name: str) -> roman.RomanNumeral:
+    return roman.RomanNumeral(figure, key.Key(key_name))
+
+
+@lru_cache(maxsize=None)
+def _chord_symbol(symbol: str) -> harmony.ChordSymbol:
+    return harmony.ChordSymbol(symbol)
+
+
+def pitch_classes_from_figure(figure: str, key_obj: key.Key) -> frozenset[int]:
+    rn = _roman(figure, key_obj.tonicPitchNameWithCase)
+    return frozenset(p.pitchClass for p in rn.pitches)
+
+
+def bass_pc_from_figure(figure: str, key_obj: key.Key) -> int:
+    rn = _roman(figure, key_obj.tonicPitchNameWithCase)
+    return rn.bass().pitchClass
+
+
+def pitch_classes_from_symbol(symbol: str) -> frozenset[int]:
+    cs = _chord_symbol(symbol)
+    return frozenset(p.pitchClass for p in cs.pitches)
+
+
+def bass_pc_from_symbol(symbol: str) -> int:
+    return _chord_symbol(symbol).bass().pitchClass
+
+
+def spelled_notes_from_figure(figure: str, key_obj: key.Key) -> list[str]:
+    """Voiced, bass-first spelled notes, e.g. ``['D4','F4','A4','C5']`` (flats as 'b').
+
+    Enharmonic spelling is preserved (``Cb``, ``E#`` in remote keys) — that is part
+    of notation reading. The bass is first, so inversion is recoverable.
+    """
+    rn = _roman(figure, key_obj.tonicPitchNameWithCase)
+    return [p.nameWithOctave.replace("-", "b") for p in rn.pitches]
+
+
+def bass_first_pcs_from_figure(figure: str, key_obj: key.Key) -> list[int]:
+    """Pitch classes in bass-first order, de-duplicated (spelling stripped).
+
+    Order preserves the bass first so inversion stays recoverable, while the
+    integers carry no enharmonic hint — the most abstract input tier.
+    """
+    seen: list[int] = []
+    rn = _roman(figure, key_obj.tonicPitchNameWithCase)
+    for p in rn.pitches:
+        if p.pitchClass not in seen:
+            seen.append(p.pitchClass)
+    return seen
+
+
+def chord_symbol_from_figure(figure: str, key_obj: key.Key) -> str:
+    """Render a Roman numeral (in a key) to a lead-sheet chord symbol string.
+
+    Uses music21's ``chordSymbolFigureFromChord``. Returns the string as-is;
+    unidentifiable chords come back as a sentinel that the verify gate rejects.
+    """
+    rn = _roman(figure, key_obj.tonicPitchNameWithCase)
+    return harmony.chordSymbolFigureFromChord(chord.Chord(rn.pitches))
+
+
+# Conventional key spellings: one per pitch class, avoiding needless double
+# accidentals so generated chord symbols stay clean.
+MAJOR_KEYS = ["C", "D-", "D", "E-", "E", "F", "F#", "G", "A-", "A", "B-", "B"]
+MINOR_KEYS = ["c", "c#", "d", "e-", "e", "f", "f#", "g", "g#", "a", "b-", "b"]

tests/test_cadence.py

@@ -0,0 +1,72 @@
+"""Tests for the cadence classifier.
+
+music21 has no cadence detector, so this is our own. It emits DCML cadence codes
+(PAC / IAC / HC / DC / PC) from the tail of an Analysis sequence. Because the
+synthetic data is root-position chord symbols with no notated voicing, PAC vs IAC
+is decided by inversion (both chords root position => PAC) rather than by soprano
+position — a documented simplification.
+"""
+from harmony_dataset.cadence import classify_cadence
+from harmony_dataset.vocabulary import Analysis
+
+
+def A(numeral, form="", figbass="", relativeroot=None):
+    return Analysis(numeral, form=form, figbass=figbass, relativeroot=relativeroot)
+
+
+class TestAuthentic:
+    def test_pac_major(self):
+        assert classify_cadence([A("ii", figbass="7"), A("V", figbass="7"), A("I")]) == "PAC"
+
+    def test_pac_minor(self):
+        assert classify_cadence([A("iv"), A("V"), A("i")]) == "PAC"
+
+    def test_iac_tonic_inverted(self):
+        assert classify_cadence([A("ii", figbass="7"), A("V", figbass="7"), A("I", figbass="6")]) == "IAC"
+
+    def test_iac_dominant_inverted(self):
+        assert classify_cadence([A("ii", figbass="7"), A("V", figbass="65"), A("I")]) == "IAC"
+
+
+class TestOtherCadences:
+    def test_half_cadence(self):
+        assert classify_cadence([A("I"), A("IV"), A("V")]) == "HC"
+
+    def test_half_cadence_after_secondary(self):
+        # I - V7/V - V  is a tonicized half cadence: ends on diatonic V
+        assert classify_cadence([A("I"), A("V", figbass="7", relativeroot="V"), A("V")]) == "HC"
+
+    def test_plagal(self):
+        assert classify_cadence([A("I"), A("IV"), A("I")]) == "PC"
+
+    def test_plagal_minor(self):
+        assert classify_cadence([A("i"), A("iv"), A("i")]) == "PC"
+
+    def test_deceptive_major(self):
+        assert classify_cadence([A("ii", figbass="7"), A("V", figbass="7"), A("vi")]) == "DC"
+
+    def test_deceptive_minor(self):
+        assert classify_cadence([A("iv"), A("V", figbass="7"), A("VI")]) == "DC"
+
+    def test_inverted_dominant_is_not_deceptive(self):
+        # V65 -> vi: the bass (leading tone) must resolve to tonic; not a DC
+        assert classify_cadence([A("I"), A("V", figbass="65"), A("vi")]) is None
+
+
+class TestNoCadence:
+    def test_ends_on_predominant(self):
+        assert classify_cadence([A("I"), A("IV"), A("ii", figbass="7")]) is None
+
+    def test_single_chord(self):
+        assert classify_cadence([A("I")]) is None
+
+    def test_empty(self):
+        assert classify_cadence([]) is None
+
+    def test_inverted_dominant_is_not_half_cadence(self):
+        # ending on an inverted V is too weak to call a half cadence
+        assert classify_cadence([A("I"), A("V", figbass="6")]) is None
+
+    def test_terminal_v7_is_not_half_cadence(self):
+        # a half cadence ends on a V triad; a terminal V7 demands resolution
+        assert classify_cadence([A("I"), A("IV"), A("V", figbass="7")]) is None

tests/test_eval.py

@@ -0,0 +1,119 @@
+"""The eval harness must parse leniently, score strictly, and give the oracle 100%."""
+import json
+import sys
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(REPO / "eval"))
+
+from score import parse_key, parse_rn, score_key, score_rn  # noqa: E402
+
+
+def _pairs(cases):
+    return [(g, {"prediction": p}) for g, p in cases]
+
+
+class TestParseRN:
+    def test_clean_two_line(self):
+        assert parse_rn("ii7 V7 IM7\ncadence: PAC") == (["ii7", "V7", "IM7"], "PAC")
+
+    def test_no_cadence(self):
+        assert parse_rn("VIM7") == (["VIM7"], None)
+
+    def test_prose_then_fenced_answer(self):
+        text = "Let me analyze this.\n```\nI ii6 I64 V\ncadence: HC\n```"
+        assert parse_rn(text) == (["I", "ii6", "I64", "V"], "HC")
+
+    def test_inline_cadence(self):
+        assert parse_rn("ii7 V7 I cadence: PAC") == (["ii7", "V7", "I"], "PAC")
+
+    def test_unicode_and_separators(self):
+        assert parse_rn("iiø7 – V⁷ – vii°6\ncadence: IAC") == (
+            ["ii%7", "V7", "viio6"],
+            "IAC",
+        )
+
+    def test_case_is_preserved(self):
+        labels, _ = parse_rn("i64 V i")
+        assert labels == ["i64", "V", "i"]  # not I64 / I
+
+    def test_garbage(self):
+        assert parse_rn("") == (None, None)
+
+
+class TestParseKey:
+    def test_plain(self):
+        assert parse_key("Eb major") == "Eb major"
+
+    def test_prose_wrapped(self):
+        assert parse_key("The key of this phrase is F# minor.") == "F# minor"
+
+    def test_lowercase_tonic(self):
+        assert parse_key("f# minor") == "F# minor"
+
+    def test_last_match_wins(self):
+        assert parse_key("This has a major sound at first, but it is B minor") == "B minor"
+
+    def test_no_key(self):
+        assert parse_key("I have no idea") is None
+
+
+class TestScoreRN:
+    GOLD = {"labels": ["ii7", "V7", "IM7"], "cadence": "PAC"}
+
+    def test_mixed_batch(self):
+        pairs = _pairs([
+            (self.GOLD, "ii7 V7 IM7\ncadence: PAC"),   # perfect
+            (self.GOLD, "ii7 V7 IM7\ncadence: IAC"),   # wrong cadence
+            (self.GOLD, "ii7 V7 I\ncadence: PAC"),     # one wrong chord
+            (self.GOLD, "no idea"),                     # unparseable-ish
+        ])
+        m = score_rn(pairs)
+        assert m["n"] == 4
+        assert m["exact"] == 0.25
+        assert m["labels_exact"] == 0.5
+        assert m["cadence_acc"] == 0.5  # garbage row has no cadence, misses PAC
+        # 3 + 3 + 2 + 0 hits of 12 gold chords ("no" != "ii7", "idea" != "V7")
+        assert m["chord_acc"] == round(8 / 12, 4)
+
+    def test_none_cadence_matches(self):
+        m = score_rn(_pairs([({"labels": ["VIM7"], "cadence": None}, "VIM7")]))
+        assert m["exact"] == 1.0
+
+
+class TestScoreKey:
+    def test_mixed_batch(self):
+        pairs = _pairs([
+            ({"target": "C major"}, "C major"),
+            ({"target": "Bb major"}, "Bb minor"),   # tonic right, mode wrong
+            ({"target": "F# minor"}, "???"),        # parse failure
+        ])
+        m = score_key(pairs)
+        assert m["exact"] == round(1 / 3, 4)
+        assert m["tonic_acc"] == round(2 / 3, 4)
+        assert m["mode_acc"] == round(1 / 3, 4)
+        assert m["parse_failures"] == 1
+
+
+class TestOracle:
+    """Feeding gold targets back as predictions must score 100% everywhere.
+
+    This round-trips every real test-split target through the response parser,
+    so any formatting the parser can't recover is caught here.
+    """
+
+    def _oracle(self, config):
+        path = REPO / "data" / config / "test.jsonl"
+        gold = [json.loads(ln) for ln in path.open()]
+        return [(g, {"prediction": g["target"]}) for g in gold]
+
+    def test_rn_configs(self):
+        for config in ("symbol_to_rn", "notes_to_rn", "pcset_to_rn"):
+            m = score_rn(self._oracle(config))
+            assert m["exact"] == 1.0, (config, m)
+            assert m["parse_failures"] == 0
+
+    def test_key_id(self):
+        m = score_key(self._oracle("key_id"))
+        assert m["exact"] == 1.0, m
+        assert m["parse_failures"] == 0

tests/test_generator.py

@@ -0,0 +1,110 @@
+"""Tests for the pool builder and multi-task generator.
+
+Locks: every emitted record is gold-verified, splits are leakage-free by shape
+(across keys AND across tasks), the brief's example is present, task framings are
+well-formed, and generation is deterministic.
+"""
+from collections import Counter
+
+from harmony_dataset.generator import build_pool, generate
+from harmony_dataset.cadence import classify_cadence
+from harmony_dataset.vocabulary import Analysis
+
+
+class TestPool:
+    def test_shapes_distinct(self):
+        pool = build_pool()
+        keys = [(s.mode, s.labels) for s in pool]
+        assert len(keys) == len(set(keys))
+
+    def test_has_curated_and_grammar_and_single(self):
+        sources = {s.source for s in build_pool()}
+        assert {"curated", "grammar", "single"} <= sources
+
+    def test_split_is_stable(self):
+        # shape -> split must be deterministic across calls. build_pool is
+        # lru_cached, so compare a FRESH build (__wrapped__) against the cached
+        # one — comparing two cached calls would be a self-comparison.
+        a = {s.shape_id: s.split for s in build_pool.__wrapped__()}
+        b = {s.shape_id: s.split for s in build_pool()}
+        assert a == b
+
+
+class TestLeakage:
+    def test_no_shape_crosses_splits(self):
+        res = generate()
+        by_shape: dict[str, set[str]] = {}
+        for r in res.records:
+            by_shape.setdefault(r.data["shape_id"], set()).add(r.split)
+        offenders = {sid: sp for sid, sp in by_shape.items() if len(sp) > 1}
+        assert not offenders, f"shapes leaking across splits: {offenders}"
+
+
+class TestVerifiedAndDeterministic:
+    def test_gold_gate_clean(self):
+        # the locked vocabulary must verify perfectly; any disagreement is a bug
+        res = generate()
+        assert res.records
+        assert res.chord_agreement_rate == 1.0
+        assert res.dropped_instances == 0
+        assert res.failures == []
+
+    # NOTE: full-pipeline determinism follows from build_pool determinism
+    # (tested above with a fresh __wrapped__ build — the only RNG lives there)
+    # plus _instantiate being pure music21 rendering. A second full generate()
+    # here would cost ~30s of suite time for no extra signal.
+
+
+class TestBriefExample:
+    def test_jazz_ii_V_I_symbol_task_present(self):
+        res = generate()
+        hits = [
+            r.data for r in res.records
+            if r.data["task"] == "symbol_to_rn"
+            and r.data["key"] == "C major"
+            and r.data.get("chords") == ["Dm7", "G7", "Cmaj7"]
+        ]
+        assert len(hits) == 1
+        assert hits[0]["target"] == "ii7 V7 IM7\ncadence: PAC"
+
+
+class TestTaskFraming:
+    def test_all_tasks_present(self):
+        tasks_seen = Counter(r.data["task"] for r in generate().records)
+        assert set(tasks_seen) == {"symbol_to_rn", "notes_to_rn", "pcset_to_rn", "key_id"}
+
+    def test_key_id_only_for_cadenced_multichord(self):
+        for r in generate().records:
+            if r.data["task"] == "key_id":
+                assert r.data["cadence"] is not None
+                assert len(r.data["labels"]) >= 3
+                assert "key:" not in r.data["input"]  # key is hidden
+                assert r.data["target"] == r.data["key"]
+
+    def test_key_id_records_are_key_determined(self):
+        # every key_id record's notes must contain scale degree 4 + leading tone
+        # (otherwise a competing key admits the same notes and the gold is moot)
+        letter = {"C": 0, "D": 2, "E": 4, "F": 5, "G": 7, "A": 9, "B": 11}
+
+        def pc(note: str) -> int:
+            core = note.rstrip("0123456789")
+            v = letter[core[0]]
+            for a in core[1:]:
+                v += 1 if a == "#" else -1
+            return v % 12
+
+        for r in generate().records:
+            if r.data["task"] != "key_id":
+                continue
+            tonic = pc(r.data["key"].split()[0] + "0")
+            present = {pc(n) for ch in r.data["notes"] for n in ch}
+            assert {(tonic + 5) % 12, (tonic + 11) % 12} <= present, r.data["input"]
+
+    def test_notes_task_hides_symbols(self):
+        for r in generate().records:
+            if r.data["task"] == "notes_to_rn":
+                assert "notes:" in r.data["input"]
+                assert "progression:" not in r.data["input"]
+                # target still matches the classifier
+                labels = [Analysis.from_dict(a).dcml_label() for a in r.data["analysis"]]
+                assert " ".join(labels) in r.data["target"]

tests/test_grammar.py

@@ -0,0 +1,71 @@
+"""Tests for the probabilistic functional-harmony grammar.
+
+The grammar must produce musically-shaped phrases: start on tonic, end on a
+recognised cadence, and (crucially) every chord must survive the gold gate when
+rendered in a key. It must be deterministic under a seed and genuinely diverse.
+"""
+from music21 import key
+
+from harmony_dataset.grammar import generate_phrases
+from harmony_dataset.cadence import classify_cadence
+from harmony_dataset.verify import verify_chord
+from harmony_dataset.vocabulary import Analysis, chord_symbol_from_figure
+
+
+class TestParseSpec:
+    def test_specs_round_trip_to_labels(self):
+        assert Analysis.parse("ii7").dcml_label() == "ii7"
+        assert Analysis.parse("IM7").dcml_label() == "IM7"
+        assert Analysis.parse("iio6").dcml_label() == "iio6"
+        assert Analysis.parse("ii%65").dcml_label() == "ii%65"
+        assert Analysis.parse("V7/V").dcml_label() == "V7/V"
+        assert Analysis.parse("viio7").dcml_label() == "viio7"
+
+
+class TestPhraseShape:
+    def test_starts_on_tonic(self):
+        for mode in ("major", "minor"):
+            for phrase in generate_phrases(mode, 40, seed=1):
+                assert phrase[0].numeral in {"I", "i"}
+                assert phrase[0].relativeroot is None
+
+    def test_ends_on_cadence(self):
+        for mode in ("major", "minor"):
+            for phrase in generate_phrases(mode, 40, seed=2):
+                assert classify_cadence(phrase) is not None
+
+    def test_reasonable_length(self):
+        for phrase in generate_phrases("major", 40, seed=3):
+            assert 2 <= len(phrase) <= 9
+
+
+class TestGoldGateCompatibility:
+    def test_every_chord_verifies_in_reference_key(self):
+        # nothing the grammar emits should fail the dual-derivation check
+        for mode, k in (("major", "C"), ("minor", "a")):
+            K = key.Key(k)
+            for phrase in generate_phrases(mode, 60, seed=4):
+                for a in phrase:
+                    sym = chord_symbol_from_figure(a.music21_figure(), K)
+                    assert verify_chord(a, sym, K).ok, f"{a.dcml_label()} -> {sym} in {k}"
+
+
+class TestDeterminismAndDiversity:
+    def test_deterministic(self):
+        a = [tuple(p.dcml_label() for p in ph) for ph in generate_phrases("major", 30, seed=7)]
+        b = [tuple(p.dcml_label() for p in ph) for ph in generate_phrases("major", 30, seed=7)]
+        assert a == b
+
+    def test_distinct_shapes(self):
+        shapes = {tuple(p.dcml_label() for p in ph) for ph in generate_phrases("major", 120, seed=9)}
+        # the grammar should yield real variety, not a handful of templates
+        assert len(shapes) >= 40
+
+    def test_uses_secondary_dominants(self):
+        seen = set()
+        for mode in ("major", "minor"):
+            for ph in generate_phrases(mode, 150, seed=11):
+                for a in ph:
+                    if a.relativeroot is not None:
+                        seen.add(a.dcml_label())
+        assert seen, "grammar never produced a secondary dominant"

tests/test_tasks.py

@@ -0,0 +1,90 @@
+"""Tests for the task framings, especially the key_id determinacy gate."""
+import pytest
+
+from harmony_dataset.tasks import render, _key_is_determined
+
+# the brief example: ii7 V7 IM7 in C major
+_ARGS = dict(
+    key="C major",
+    symbols=["Dm7", "G7", "Cmaj7"],
+    notes=[["D4", "F4", "A4", "C5"], ["G4", "B4", "D5", "F5"], ["C4", "E4", "G4", "B4"]],
+    pcs=[[2, 5, 9, 0], [7, 11, 2, 5], [0, 4, 7, 11]],
+    labels=["ii7", "V7", "IM7"],
+    cadence="PAC",
+)
+
+
+class TestFormats:
+    def test_symbol(self):
+        r = render("symbol_to_rn", **_ARGS)
+        assert r.input == "key: C major\nprogression: Dm7 G7 Cmaj7"
+        assert r.target == "ii7 V7 IM7\ncadence: PAC"
+
+    def test_notes(self):
+        r = render("notes_to_rn", **_ARGS)
+        assert "notes: D4 F4 A4 C5 | G4 B4 D5 F5 | C4 E4 G4 B4" in r.input
+
+    def test_pcset(self):
+        r = render("pcset_to_rn", **_ARGS)
+        assert "pitch classes: [2 5 9 0] | [7 11 2 5] | [0 4 7 11]" in r.input
+
+    def test_unknown_task_raises(self):
+        with pytest.raises(ValueError):
+            render("nope", **_ARGS)
+
+
+class TestKeyIdGate:
+    def test_determined_case_passes(self):
+        r = render("key_id", **_ARGS)
+        assert r is not None
+        assert r.target == "C major"
+        assert "key:" not in r.input
+
+    def test_smoking_gun_excluded(self):
+        # I V7/V V in C == IV V7 I in G (note-identical, stronger reading).
+        # No scale degree 4 (F) anywhere -> key not determined -> excluded.
+        args = dict(_ARGS)
+        args.update(
+            symbols=["C", "D7", "G"],
+            notes=[["C4", "E4", "G4"], ["D4", "F#4", "A4", "C5"], ["G4", "B4", "D5"]],
+            pcs=[[0, 4, 7], [2, 6, 9, 0], [7, 11, 2]],
+            labels=["I", "V7/V", "V"],
+            cadence="HC",
+        )
+        assert render("key_id", **args) is None
+
+    def test_plagal_without_leading_tone_excluded(self):
+        # I IV I in C == V I V in F: ambiguous, no B anywhere.
+        args = dict(_ARGS)
+        args.update(
+            symbols=["C", "F", "C"],
+            notes=[["C4", "E4", "G4"], ["F4", "A4", "C5"], ["C4", "E4", "G4"]],
+            pcs=[[0, 4, 7], [5, 9, 0], [0, 4, 7]],
+            labels=["I", "IV", "I"],
+            cadence="PC",
+        )
+        assert render("key_id", **args) is None
+
+    def test_no_cadence_excluded(self):
+        args = dict(_ARGS, cadence=None)
+        assert render("key_id", **args) is None
+
+    def test_too_short_excluded(self):
+        args = dict(_ARGS)
+        args.update(symbols=["G7", "C"], notes=_ARGS["notes"][1:], pcs=_ARGS["pcs"][1:],
+                    labels=["V7", "I"], cadence="PAC")
+        assert render("key_id", **args) is None
+
+
+class TestDeterminacyHelper:
+    def test_tritone_rule(self):
+        # C major needs F (5) and B (11)
+        assert _key_is_determined("C major", [[0, 4, 7], [5, 9, 0], [7, 11, 2]])
+        assert not _key_is_determined("C major", [[0, 4, 7], [7, 11, 2]])       # no F
+        assert not _key_is_determined("C major", [[0, 4, 7], [5, 9, 0]])        # no B
+
+    def test_accidental_keys(self):
+        # Ab major: degree 4 = Db (1), leading tone = G (7)
+        assert _key_is_determined("Ab major", [[8, 0, 3], [1, 5, 8], [3, 7, 10]])
+        # F# minor: degree 4 = B (11), leading tone = E# (5)
+        assert _key_is_determined("F# minor", [[6, 9, 1], [11, 2, 6], [1, 5, 8]])

tests/test_verify.py

@@ -0,0 +1,45 @@
+"""Tests for the dual-derivation gold gate.
+
+A chord passes only if the pitch content implied by its Roman-numeral label
+(rendered by music21's roman engine) matches the pitch content implied by its
+printed chord symbol (parsed by music21's independent chord-symbol parser),
+including the bass. Disagreement means the label and the symbol shown to the
+model denote different chords — that item must never reach the dataset.
+"""
+from music21 import key
+
+from harmony_dataset.vocabulary import Analysis
+from harmony_dataset.verify import verify_chord
+
+
+K = key.Key("C")
+
+
+class TestPasses:
+    def test_matching_chord(self):
+        assert verify_chord(Analysis("ii", figbass="7"), "Dm7", K).ok
+
+    def test_matching_maj7(self):
+        assert verify_chord(Analysis("I", form="M", figbass="7"), "Cmaj7", K).ok
+
+    def test_matching_inversion_bass(self):
+        # V65 = G7/B; bass must line up too
+        assert verify_chord(Analysis("V", figbass="65"), "G7/B", K).ok
+
+
+class TestFails:
+    def test_wrong_quality(self):
+        # Dm7b5 (half-dim) != ii7 (minor 7)
+        res = verify_chord(Analysis("ii", figbass="7"), "Dm7b5", K)
+        assert not res.ok
+        assert res.figure_pcs != res.symbol_pcs
+
+    def test_wrong_bass(self):
+        # right notes, wrong inversion: V7 (root) vs G7/B (first inversion)
+        res = verify_chord(Analysis("V", figbass="7"), "G7/B", K)
+        assert not res.ok
+        assert "bass" in res.reason.lower()
+
+    def test_unparseable_symbol(self):
+        res = verify_chord(Analysis("V", figbass="7"), "not-a-chord", K)
+        assert not res.ok

tests/test_vocabulary.py

@@ -0,0 +1,127 @@
+"""Tests for the DCML label grammar and the music21 bridge.
+
+These lock the representation decisions from the plan:
+- DCML feature-decomposed labels (numeral / form / figbass / changes / relativeroot)
+- the single divergence from music21 figures: half-diminished '%' (DCML) vs 'ø' (music21)
+- Cmaj7 -> IM7 (clean maj7, which music21's analytic figure gets wrong as 'I7')
+"""
+from music21 import key
+
+from harmony_dataset.vocabulary import (
+    Analysis,
+    pitch_classes_from_figure,
+    pitch_classes_from_symbol,
+    bass_pc_from_figure,
+    bass_first_pcs_from_figure,
+    spelled_notes_from_figure,
+    chord_symbol_from_figure,
+    MAJOR_KEYS,
+    MINOR_KEYS,
+)
+
+
+class TestDCMLLabels:
+    def test_plain_seventh(self):
+        a = Analysis("ii", figbass="7")
+        assert a.dcml_label() == "ii7"
+        assert a.music21_figure() == "ii7"
+
+    def test_major_seventh_is_M(self):
+        # the crux: Cmaj7 -> IM7, NOT the music21 analytic 'I7'
+        a = Analysis("I", form="M", figbass="7")
+        assert a.dcml_label() == "IM7"
+        assert a.music21_figure() == "IM7"
+
+    def test_half_diminished_glyph_diverges(self):
+        a = Analysis("ii", form="%", figbass="7")
+        assert a.dcml_label() == "ii%7"       # DCML uses %
+        assert a.music21_figure() == "iiø7"   # music21 uses ø
+
+    def test_diminished_seventh(self):
+        a = Analysis("vii", form="o", figbass="7")
+        assert a.dcml_label() == "viio7"
+        assert a.music21_figure() == "viio7"
+
+    def test_secondary_dominant(self):
+        a = Analysis("V", figbass="7", relativeroot="V")
+        assert a.dcml_label() == "V7/V"
+        assert a.music21_figure() == "V7/V"
+
+    def test_inversion_figbass(self):
+        a = Analysis("V", figbass="65")
+        assert a.dcml_label() == "V65"
+
+    def test_roundtrip_dict(self):
+        a = Analysis("ii", form="%", figbass="65", relativeroot="V")
+        assert Analysis.from_dict(a.to_dict()) == a
+
+
+class TestPitchClasses:
+    def test_figure_pitch_classes_c_major(self):
+        K = key.Key("C")
+        assert pitch_classes_from_figure("ii7", K) == frozenset({0, 2, 5, 9})
+        assert pitch_classes_from_figure("V7", K) == frozenset({2, 5, 7, 11})
+        assert pitch_classes_from_figure("IM7", K) == frozenset({0, 4, 7, 11})
+
+    def test_symbol_pitch_classes(self):
+        assert pitch_classes_from_symbol("Dm7") == frozenset({0, 2, 5, 9})
+        assert pitch_classes_from_symbol("G7") == frozenset({2, 5, 7, 11})
+        assert pitch_classes_from_symbol("Cmaj7") == frozenset({0, 4, 7, 11})
+
+    def test_minor_key_raised_leading_tone(self):
+        # V7 in A minor is E7 (G#), not Em7
+        K = key.Key("a")
+        assert pitch_classes_from_figure("V7", K) == frozenset({2, 4, 8, 11})
+
+    def test_bass_pc_of_inversion(self):
+        K = key.Key("C")
+        # V65 = G7 in first inversion, bass = B (pc 11)
+        assert bass_pc_from_figure("V65", K) == 11
+        # root position V7, bass = G (pc 7)
+        assert bass_pc_from_figure("V7", K) == 7
+
+
+class TestRepresentations:
+    def test_spelled_notes_bass_first(self):
+        K = key.Key("C")
+        assert spelled_notes_from_figure("ii7", K) == ["D4", "F4", "A4", "C5"]
+        # first-inversion dominant seventh: bass is the third (B)
+        assert spelled_notes_from_figure("V65", K)[0] == "B4"
+
+    def test_spelled_notes_flats_use_b(self):
+        # Eb minor VI = Cb major triad; must render 'Cb', never 'C-'
+        notes = spelled_notes_from_figure("VI", key.Key("e-"))
+        assert notes[0].startswith("Cb")
+        assert all("-" not in n for n in notes)
+
+    def test_bass_first_pcs_dedup_and_order(self):
+        K = key.Key("C")
+        assert bass_first_pcs_from_figure("ii7", K) == [2, 5, 9, 0]
+        # V65 bass is B (pc 11) — inversion recoverable from first element
+        assert bass_first_pcs_from_figure("V65", K)[0] == 11
+
+
+class TestChordSymbolGeneration:
+    def test_symbol_from_figure_major_key(self):
+        K = key.Key("C")
+        assert chord_symbol_from_figure("ii7", K) == "Dm7"
+        assert chord_symbol_from_figure("V7", K) == "G7"
+        assert chord_symbol_from_figure("IM7", K) == "Cmaj7"
+        assert chord_symbol_from_figure("I", K) == "C"
+
+    def test_symbol_from_figure_minor_key(self):
+        K = key.Key("a")
+        assert chord_symbol_from_figure("V7", K) == "E7"
+        assert chord_symbol_from_figure("i", K) == "Am"
+
+
+class TestKeyInventory:
+    def test_twelve_of_each(self):
+        assert len(MAJOR_KEYS) == 12
+        assert len(MINOR_KEYS) == 12
+
+    def test_all_pitch_classes_covered(self):
+        maj_pcs = {key.Key(k).tonic.pitchClass for k in MAJOR_KEYS}
+        min_pcs = {key.Key(k).tonic.pitchClass for k in MINOR_KEYS}
+        assert maj_pcs == set(range(12))
+        assert min_pcs == set(range(12))