fts-specgen-dataset

10 500 pairs of "task in ordinary Russian → executable FTS specification". 9 000 train, 1 500 holdout. Every single document was run through the real FTS compiler — parsed, type checked, its examples executed, its theorem proved and certified — and only what passed the whole gate is in these files.

It also ships the thing that makes that sentence worth anything: a negative control of 4 400 deliberately corrupted documents, eleven kinds of corruption, with the gate's verdict on every one. The gate catches 91.6 %, and the card tells you which 8.4 % it misses and why.

This is what trained digitable-lol/specgen-qwen3-1.7b.

---

1. Read this first

1.1 "Passed the compiler" is a claim about form, not about meaning

The gate proves that a document compiles, type checks, executes its own examples, and proves its own theorem. It does not prove that the document means what the task text asked for.

Semantic fidelity was never measured. The generator builds the task text and the document from the same underlying structure, so a divergence can only arise as a bug in tools/task.py — but the rate of such bugs is unknown, and "unknown" is the honest word. If you need a corpus where the natural-language request is guaranteed to describe the formal artefact, this is not verified to be one.

1.2 A hole in this dataset, found by the model that trained on it

Not one of the 9 000 training documents contains a utility and a theorem at the same time.

training documents	count
utility, no theorem	6 451
theorem, no utility	1 185
neither	1 364
both	0

The holdout does contain the combination — template CMB-UTL-THM, 129 documents — because that template was assigned to the holdout side of the split. The consequence showed up downstream, in the model: of the 127 CMB-UTL-THM documents it produced that compiled cleanly, 0 contained the theorem the task asked for, while on the other 324 theorem-bearing holdout documents it scored 324/324.

This is a defect of the data, not of the model, and it is a good demonstration of § 1.1: the compiler accepts a specification with no theorem, because a specification with no theorem is formally valid. Nothing in the gate could have caught it. It was found by comparing generated documents against their reference structure — a check this dataset's own construction never had to perform.

If you train on this corpus, the model you get will not learn to combine a utility with a theorem in one document, because it will never have seen it done.

1.3 Russian only, and one specific language

Every task text is Russian and every document uses the Russian surface syntax of FTS. The English surface of the language is not covered at all. The documents are also specific to FTS as implemented by @digitable-lol/fts — this is not a general formal-methods corpus.

2. What is in it

documents	10 500 (9 000 train / 1 500 holdout)
passed the gate	10 500 of 10 500 generated candidates
rejected in the final run	0
subject areas	62 (50 train, 12 holdout)
structural templates	33 (25 train, 8 holdout)
language constructs tracked	74 — all 74 present in both train and holdout
conforms to the GBNF grammar	10 500 of 10 500 (100 %)
gate throughput	4 200–4 470 documents/second, in-process
size	47 MiB train + 6.9 MiB holdout

Language elements across the corpus: 32 609 пример, 28 549 fields, 12 670 правило, 11 990 объект/структура, 7 166 утилита, 5 328 морфизм, 5 227 свойство, 1 638 теорема.

The three holdout strata

The split divides the space of templates and subject areas and is written to reports/split.json before the first document is generated. A document is training data only if both its template and its area are on the training side.

stratum	documents	what is new
новая_область	501	familiar structural form, unseen subject area
новый_шаблон	501	unseen structural form, familiar area
новый_шаблон_новая_область	498	neither was ever seen — the strict one

Measured leakage invariants (reports/stats.json → leakage_check, all hold): 0 shared documents, 0 shared task texts, 0 holdout templates leaked into train, 0 holdout areas leaked into train, and the strict stratum verifiably uses only unseen templates and only unseen areas.

One constraint is enforced while building the split rather than checked afterwards: every tracked language construct must survive in at least one training template, or the model would never see it at all.

3. The negative control — the part that is worth more than the corpus

A dataset whose every row "passed the filter" tells you nothing until you know whether the filter can fail anything. So 4 400 known-good documents were corrupted on purpose, eleven ways, and put back through the same gate.

4 030 of 4 400 caught — 91.6 %.

corruption	caught	what the gate said
example: expected value changed	100.0 %	FTS_EXAMPLE_MISMATCH
syntax: C-like (field: type)	100.0 %	PARSE_ERROR
field not declared, used in a rule	100.0 %	FTS_UTILITY_FIELD
example: required field dropped	100.0 %	FTS_UTILITY_EXAMPLE_FIELD
indentation: four spaces instead of two	100.0 %	PARSE_ERROR
theorem: unknown morphism	100.0 %	PARSE_ERROR
type: string where a number belongs	100.0 %	FTS_UTILITY_EXAMPLE_TYPE
utility: different return type	100.0 %	FTS_UTILITY_INITIAL_TYPE
name: unclosed guillemet	74.5 %	PARSE_ERROR
rule: threshold moved by one	72.8 %	FTS_EXAMPLE_MISMATCH
morphism: reversed	60.2 %	PARSE_ERROR
total	91.6 %

The last two rows are the limits of the method, and they are the reason this section exists:

• Threshold moved by one is the only semantic corruption in the list — the document stays well-formed and well-typed and simply computes something else. Before the generator was changed, the gate caught 5.0 % of these: the examples in a document never happened to touch the boundary they were testing. Adding a pair of examples "exactly at the threshold" and "one below it" moved it to 72.8 %, and moved the overall catch rate from 85.8 % to 91.6 %. That change was made because of this measurement, not before it — which is the argument for running a negative control at all.
• A reversed morphism is caught only when it breaks a theorem's type chain. In a document with no theorem, a reversed morphism is still a perfectly correct document. The reference toolchain records exactly this case in fts-gate/examples/fallacies/reversed-morphism.fts.

So the honest formulation, and the one the model card repeats:

The gate guarantees that a document compiles, type checks, executes its examples and proves its theorem. It does not guarantee that the document means what was asked.

3.1 The grammar is not the compiler

The same 4 400 mutants were run through the GBNF recogniser: it accepts 3 302 and rejects 1 098. The grammar catches syntactic corruption and nothing else — type errors and semantic errors pass it cleanly. Constrained decoding is not a correctness check, and this is the measurement that says so.

3.2 It ships as data, not as a table

negative_control/ contains all 4 400 mutated documents and the gate's verdict on each, so you can re-run the whole thing against your own checker instead of taking the table above on trust. It is deterministic (random.Random(11) over the shipped corpus) and was regenerated and re-verified for this publication: 4 030/4 400, every per-mutation count and every diagnostic code identical to the published summary.

4. Two other things that were measured about the gate

It rejected 17.2 % during development. On the first full run the gate threw out 1 787 of 10 400 candidates, all PARSE_ERROR, all from a single bug: a name of the form «Признак «есть медсправка» установлен» terminated at the first closing guillemet. The compiler found it; review had not. The final run's 0 rejections are what a fixed generator looks like, not what a blind filter looks like.

The same gate on the pre-existing hand-written corpus. Of 141 unique .fts documents found on the machine, 92 parse and pass; 42 do not parse at all (module wrappers, fragments, deliberately broken examples from fts-gate/examples/fallacies and refusals), 6 fail on their examples, 1 on types. The gate is not tuned to accept everything it is shown.

5. Coverage: this corpus is denser than the corpus it came from

In those 92 hand-written documents, 11 of the 74 tracked constructs never appear at all and 21 appear in five documents or fewer. In this dataset the minimum is 127 training documents (сравн:больше) and 19 holdout documents.

construct	hand-written corpus (92 docs)	train	holdout
вложена структура	0	243	21
не равно	0	267	25
затем применить морфизм	0	304	147
получаем	0	392	153
возвращает дату	0	396	21
применить морфизм	0	589	166
морфизм: из / в	0	786	302
структура	0	882	61
является текстом	0	1 131	80
вложен объект	1	249	19
является датой	2	1 035	169
возвращает признак	3	1 182	61

Full table for all 74 constructs: reports/coverage_vs_corpus.json.

6. Row format

{"id": "...", "split": "train", "stratum": null,
 "prompt": "<task in Russian>",
 "completion": "<the FTS specification>",
 "meta": {"skeleton": "...", "domain": "...", "register": "...", "quote_style": "...",
          "constructs": [...], "gate": {...}, "summary": {...}, "context": {...},
          "sha256": "..."}}

The system prompt is not duplicated into every row — it is one line, it is identical for all 10 500, and it lives in reports/stats.json → system_prompt:

Ты пишешь исполняемые спецификации на языке FTS (русская поверхность). Ответ — только текст спецификации, без пояснений и без ограждений кода.

Build messages from that plus the prompt/completion pair.

meta.gate records what the gate saw for that document, including certificate_digest for the 1 638 documents with a theorem. meta.context is the data a theorem is proved against, and is present only for those documents.

Task variety

Task texts are written in five registers, roughly evenly distributed: тз (technical brief in prose), тикет (bulleted ticket), письмо (letter from a client), регламент (numbered clauses), просьба (a short imperative). The registers are deliberately shared between train and holdout: the holdout measures transfer to an unseen structural form and an unseen subject area, not to an unseen writing style.

A task must fully determine its document — thresholds, initial value, properties and every test case are named explicitly — or the model would be learning to guess rather than to translate.

7. Files and loading

data/train.jsonl                        9 000 rows, canonical
data/holdout.jsonl                      1 500 rows, canonical, each with `stratum`
hf/train.jsonl, hf/holdout.jsonl        the same rows, Arrow-safe (see below)
hf/negative_control.jsonl               4 400 mutants joined to their verdicts
negative_control/mutants.jsonl          4 400 corrupted documents
negative_control/verdicts.jsonl         the gate's verdict on each
negative_control/gate_sensitivity.json  the summary table of § 3
reports/split.json                      the template/area split, written before generation
reports/stats.json                      full statistics, coverage, leakage checks
reports/coverage_vs_corpus.json         the language tail (§ 5)
reports/grammar_conformance.json        10 500 / 10 500 accepted
fts.gbnf                                the grammar, for constrained decoding
MANIFEST.json                           sha256 of every published file

from datasets import load_dataset

ds = load_dataset("digitable-lol/fts-specgen-dataset")                    # train, holdout
nc = load_dataset("digitable-lol/fts-specgen-dataset", "negative_control")

Why the dataset is here twice. meta is a free-form object: meta.context alone takes 55 distinct key-sets across the corpus — one per subject area — and meta itself has two key-sets, because only documents with a theorem carry context.

On datasets ≥ 5 this is fine, and that was checked rather than assumed: load_dataset("json", data_files="data/train.jsonl") was run on datasets 5.0.1, loads all 9 000 rows, and types the column as Json, handing back a plain dict. Earlier versions infer an Arrow struct from a sample of rows and fail on the union.

hf/ sidesteps the question entirely and is what the dataset viewer and the configs above point at: meta_json carries the original object as a string (json.loads round-trips it exactly), alongside lifted scalar columns skeleton, domain, register, quote_style, n_utilities, n_examples, n_theorems, has_context, so you can filter without parsing. Train on data/; browse and filter with hf/. The same problem and the same fix are documented in digitable-lol/digit-router-dataset.

One difference between the two copies, stated because silent divergence is how a corpus gets a reputation. In hf/ the stratum column is "" for training rows; in data/ it is null, which is the honest value — a training document belongs to no stratum. Every training row has a null stratum, so Arrow types that column null in the train split and string in the holdout split, and the two then cannot share one schema; load_dataset fails on the second split. Flattening it to "" in the view is the whole of the difference. Nothing else differs, and meta_json is byte-equivalent to data/'s meta.

8. Reproduction

python3 tools/generate.py --train 9000 --holdout 1500
node    tools/verify.mjs < dataset/candidates.jsonl > work/verdicts.jsonl
python3 tools/assemble.py
python3 tools/check_dataset.py                 # independent re-check: 10500/10500
node    tools/grammar_check.mjs dataset/train.jsonl dataset/holdout.jsonl

# the negative control
python3 tools/mutate.py work/final.jsonl work/mutants.jsonl 400
node    tools/verify.mjs < work/mutants.jsonl > work/mutant_verdicts.jsonl

The split is deterministic (SPLIT_SEED = 20260806) and so is generation (random.Random(f"{seed}:{skeleton}:{domain}:{round}")), so a re-run reproduces the same files. Reproducing the gate verdicts requires the FTS compiler.

9. Limits — read before using

1. Semantic fidelity is unmeasured (§ 1.1). The largest gap.
2. No document combines a utility with a theorem (§ 1.2). A measured hole with a measured downstream consequence.
3. Synthetic throughout. Task texts are composed from registers and templates, not collected from people. Indirect, elliptical and under-specified requests — the normal way humans ask for things — are absent by construction, because a task here must fully determine its document.
4. Russian only, and one language's Russian surface (§ 1.3).
5. 33 templates and 62 areas is not the space of specifications anyone might want. It is the space this generator covers.
6. The gate's own blind spots are 8.4 %, itemised in § 3, and they are concentrated in exactly the corruption that matters most: a semantically wrong threshold in a syntactically perfect document.
7. Coverage warnings are not rejections. FTS_COVERAGE_HOLE, FTS_RULE_OVERLAP, FTS_PROPERTY_UNATTAINABLE and FTS_PROPERTY_VIOLATED are recorded in meta.gate.coverage_warnings but do not fail a document. This is measured, not assumed: the toolchain's own reference example flang-v6/examples/utilities/discount.fts raises FTS_PROPERTY_VIOLATED and FTS_PROPERTY_UNATTAINABLE itself, because the language has no way to declare that a money field is non-negative, so the analyser always finds a negative input. Rejecting on that signal would mean rejecting an idiom of the language.

10. Origin and licensing

BSD-2-Clause.

The FTS language and its compiler (@digitable-lol/fts) and the verification gate (@digitable-lol/fts-gate) are both BSD-2-Clause and both belong to this organisation. The corpus was generated from them by this project's own code, and fts.gbnf is shipped here under the same terms.

No teacher model was used anywhere in the pipeline. Every document was constructed programmatically and then checked by the compiler; expected example values come from the language's own reference interpreter and property bounds from conservative analytic estimates.

There is no third-party copyleft question here, which is a deliberate contrast with digitable-lol/digit-router-dataset, where there is one and where this organisation says so rather than picking a convenient tag.

11. Integrity

MANIFEST.json lists the sha256 of every published file, recorded at upload time on the machine that produced it. Each document additionally carries its own meta.sha256.

---

12. По-русски

Что это. 10 500 пар «задание на обычном русском → исполняемая спецификация FTS»: 9 000 train, 1 500 holdout. Каждый документ прогнан через настоящий компилятор FTS — разобран, типизирован, его примеры исполнены, его теорема доказана и сертифицирована; в файлы попало только то, что прошло гейт целиком. Это те данные, на которых обучен digitable-lol/specgen-qwen3-1.7b.

Главная оговорка. «Прошло компилятор» — утверждение о форме, не о смысле. Гейт доказывает, что документ компилируется, типизируется, исполняет свои примеры и доказывает свою теорему. Что он означает ровно то, что просили словами в задании, — не измерено. Генератор строит задание и документ из одной структуры, поэтому расхождение возможно только как ошибка в tools/task.py, и её масштаб неизвестен.

Дыра в датасете, найденная обученной на нём моделью. Ни один из 9 000 обучающих документов не содержит утилиту и теорему одновременно: 6 451 с утилитой без теоремы, 1 185 с теоремой без утилиты, 1 364 без того и другого, ноль с обоими. В holdout комбинация есть — шаблон CMB-UTL-THM, 129 документов. Последствие проявилось в модели: из 127 таких документов, которые она написала и которые чисто скомпилировались, теорему содержат 0, при 324/324 на остальных теоремах holdout. Компилятор здесь бессилен: документ без теоремы формально валиден. Это дефект данных, и он тут написан.

Негативный контроль — самое ценное в этой публикации. Фраза «все примеры прошли фильтр» ничего не значит, пока не известно, способен ли фильтр вообще что-то отвергнуть. 4 400 заведомо исправных документов испорчены намеренно — одиннадцатью способами — и пропущены через тот же гейт. Поймано 4 030 из 4 400 — 91,6 %. Восемь видов порчи ловятся на 100 %; три — нет: незакрытая ёлочка 74,5 %, сдвинутый на единицу порог 72,8 %, перевёрнутый морфизм 60,2 %.

Две последние строки — граница метода. Сдвинутый порог — единственная чисто смысловая порча в списке: документ остаётся корректным и просто считает другое. До появления граничных примеров ловилось 5,0 % — примеры просто не задевали проверяемую границу; после добавления пары «ровно на пороге» и «на единицу ниже» стало 72,8 %, а общая доля выросла с 85,8 % до 91,6 %. Это изменение сделано по результату замера, а не заранее, и в этом весь смысл негативного контроля. Перевёрнутый морфизм ловится только когда ломает типовую цепочку теоремы: в документе без теоремы он остаётся корректным документом.

Негативный контроль опубликован данными, а не таблицей: все 4 400 испорченных документов и вердикт гейта по каждому лежат в negative_control/, так что таблицу выше можно перепроверить своим инструментом. Он детерминирован и был перегенерирован и перепроверен при подготовке этой публикации — 4 030/4 400, все счётчики и все коды диагностик совпали с опубликованной сводкой.

Грамматика — не компилятор. Тот же распознаватель GBNF на тех же 4 400 мутантах принимает 3 302 и отвергает 1 098: синтаксическую порчу он ловит, типовую и смысловую — нет. Constrained decoding не является проверкой корректности, и это то измерение, которое об этом говорит.

Разделение — до генерации. reports/split.json делит пространство шаблонов и областей и пишется до построения первого документа. Три страты: новая_область (501), новый_шаблон (501), новый_шаблон_новая_область (498, самая строгая). Утечка измерена и равна нулю по всем пяти инвариантам.

Что ещё измерено про гейт. По ходу разработки он отверг 1 787 из 10 400 (17,2 %) — все PARSE_ERROR из-за одной ошибки в именах с вложенными ёлочками; нашёл её компилятор, а не ревью. Тот же гейт на исходном рукописном корпусе: из 141 документа проходят 92, 42 не разбираются вовсе, 6 падают на примерах, 1 — на типах. Гейт не устроен так, чтобы принимать всё подряд.

Ограничения: смысловая верность не измерена; нет ни одного документа с утилитой и теоремой сразу; всё синтетическое — живых пользовательских формулировок нет по построению; только русский; 33 шаблона и 62 области — это охват генератора, а не пространство спецификаций; слепые зоны гейта — 8,4 %, и они сосредоточены ровно там, где важнее всего.

Лицензия — BSD-2-Clause. Язык FTS, компилятор и гейт принадлежат этой же организации и лицензированы так же; teacher-модель не использовалась нигде. Нерешённого вопроса о копилефте здесь нет — в отличие от digit-router-dataset, где он есть и где мы это пишем прямо, а не выбираем удобный тег.