---
license: apache-2.0
pretty_name: Verified Analytics Tasks
language:
  - en
task_categories:
  - text-generation
  - table-question-answering
size_categories:
  - n<1K
tags:
  - reinforcement-learning
  - rlvr
  - verifiable-rewards
  - verifier
  - synthetic
  - data-analysis
  - data-engineering
  - sql
  - regex
  - evaluation
configs:
  - config_name: experience
    data_files: tables/01_experience.jsonl
  - config_name: fixture_generators
    data_files: tables/02_fixture_generators.jsonl
  - config_name: sft_examples
    data_files: tables/06_sft_examples.jsonl
  - config_name: rollouts
    data_files: tables/07_rollouts.jsonl
  - config_name: preference_pairs
    data_files: tables/08_preference_pairs.jsonl
  - config_name: verifiers
    data_files: tables/09_verifiers.jsonl
  - config_name: rubric_items
    data_files: tables/14_rubric_items.jsonl
---

# Verified Analytics Tasks

150+ mainly small analytics and data-engineering tasks. The point of the set is
the answer key: every task ships its own automated checker, and every gold
answer was run through that checker and scored a clean 1.0 before the task was
allowed in. So the labels are more like "here's the checker, score it
yourself" instead of "just trust me bro."

I wanted to create a synthetic dataset inspired by this paper:
[Autodata: An agentic data scientist to create high quality synthetic data](https://arxiv.org/abs/2606.25996),
while trying to be very spend-savvy. Deterministic Python computes both the
fixture and the gold answer from the same seed, so there are no frontier-model
fingerprints on the labels, and nothing to relitigate when someone's terms of
service change on a Tuesday *cough cough*.

## What's inside

Each task is a prompt over a seeded CSV or SQLite fixture, drawn from 15
checker templates across three families:

- **Analytics**: grouped sums/counts/means, filtered totals, top-N,
  dedupe-then-aggregate, date windows, pivots, joins, threshold flags. Answers
  are JSON values, checked by value with float tolerance (`math.isclose`,
  never `==`).
- **Regex**: the answer is a pattern checked by what it extracts from
  held-out test strings, never by comparing pattern text.
- **SQL**: the answer is a query, checked by executing it and the reference
  query against the same fixture and comparing result rows.

Every template embeds a deliberate trap where the specific plausible-but-wrong
answer it's built to catch, like forgetting `abs()`, using `>` where `>=` is
correct at a boundary, counting nulls as zero, or dropping a `status='paid'`
filter. Each checker is unit-tested against three cases: a correct answer, the
trap, and a malformed one.

## The tables

The dataset compiles to seven JSONL tables, one config each in the viewer:

| config | what it holds |
|---|---|
| `experience` | one row per task: prompt, fixture reference, template, gold answer |
| `fixture_generators` | the seeded generator spec that produces each fixture |
| `sft_examples` | prompt → gold-answer pairs, ready for supervised fine-tuning |
| `rollouts` | each gold answer replayed through its own checker (all score 1.0): a verification-pass log, not captured model output |
| `preference_pairs` | chosen (gold, 1.0) vs. rejected (a deterministic near-miss, 0.0), with the checker's rejection reason attached |
| `verifiers` | the checker for each task |
| `rubric_items` | the scoring criteria behind each checker |

## How the labels are produced

Every template implements the same contract:

```python
generate(seed, params)             # writes the fixture file(s)
reference(params)                  # returns the gold answer
check(agent_answer, gold, params)  # -> {"gate_passed": bool, "score": float, "reason": str}
```

Checking gates first: wrong shape scores 0 with no partial credit, and only
answers that clear the gate get scored. A task is admitted only if
`reference()`'s own output scores 1.0 through `check()`, just to guarantee
that the set is "verified" rather than "labelled."

## Intended use

This is a verifiable-task suite for RL-with-verifiable-rewards (RLVR) and for
gradeable evaluation, where you need a reward signal you can trust without a
model or a human in the loop. It is not a distillation corpus, there are no
captured agent traces here.

## Limitations

Treat this as the limitations section of a paper, not fine print.

- **The preference pairs are uneven in signal.** For the SQL and regex
  templates, both sides of a pair are programs and the checker's row-set
  comparison is binary, so the chosen/rejected gap attempts to reflect a real
  behavioural difference, those are the sharp pairs. For the analytics
  templates, both sides are bare numeric values, and the rejected side is a
  deterministic perturbation of the gold number. A model can often tell those
  apart without understanding why one is right, so the signal is weaker. Each
  row is labelled with its `signal` level so you can filter; if you want an
  unimpeachable DPO seed, take the program-valued pairs and leave the rest.
- **It's synthetic and narrow.** Every fixture is generated, not sampled from
  real-world data, and the domain is analytics/data-engineering specifically.
  Good for a clean reward signal but still not a substitute for messy (and
  expensive) real inputs.
- **Difficulty is bounded.** These are well-posed, single-mechanism tasks. A
  careful solver clears them, the value is a trustworthy checker on a known
  mechanism, not an unsaturated difficulty frontier.
- **Small by design.** 151 tasks across 15 templates. Enough to be useful as
  an RLVR/eval seed; not a large-scale training corpus.

## License

Apache-2.0, covering both the data and the checker code the tables reference.