rewrite dataset card

README.md

@@ -49,26 +49,26 @@ configs:
 
 # Typed Decisions
 
-A benchmark for **typed probabilistic decisions over shared state**: given one
-piece of unstructured state, answer several typed questions at once, each with a
-calibrated probability distribution rather than a single label.
+A benchmark for typed probabilistic decisions over shared state. You give a
+model one piece of unstructured state. It answers several typed questions about
+that state at once, and every answer is a probability distribution rather than a
+single label.
 
-It follows the System One decision schema used by
-[TypeSafe AI](https://typesafe.ai) — three question primitives (`noul`, `choice`,
-`score`) — so a row is directly replayable against any API that implements that
-shape. This is an **independent** benchmark built to study the architecture; it
-is not affiliated with TypeSafe, and it is not a reproduction of their Jev model.
+The schema follows the System One primitives used by
+[TypeSafe AI](https://typesafe.ai): `noul`, `choice` and `score`. A row replays against any API that implements that shape. This benchmark is
+independent. It is not affiliated with TypeSafe and it does not reproduce
+their Jev model.
 
 ## What it is for
 
-The question behind the dataset: *does decomposing a workflow into typed
-probabilistic decisions — especially with a shared encoder — give a favourable
-accuracy / calibration / latency trade-off compared with direct classification
-or with prompting an LLM?*
+One question sits behind the dataset. Does breaking a workflow into typed
+probabilistic decisions, especially with a shared encoder, buy you a better
+accuracy / calibration / latency trade-off than direct classification or than
+prompting an LLM?
 
-Answering that needs a benchmark where several typed questions share one input,
-where the answers are genuinely probabilistic, and where latency per decision is
-measurable. That is what this is.
+Answering that needs several typed questions over one input, answers that are
+genuinely probabilistic, and latency you can measure per decision. That is what
+this is.
 
 ## The three question types
 
@@ -78,8 +78,8 @@ measurable. That is what this is.
 | `choice` | one of N labels | a distribution over labels, plus confidence |
 | `score` | an ordered rubric | a distribution over integer levels, plus an *expected* score that may fall between levels |
 
-Every option carries a written description (`criteria`). The descriptions are
-part of the input: a bare label list is a different, easier task.
+Every option carries a written description in `criteria`. Those descriptions are part of the input. Strip them to a bare label list and
+you have a different, easier task.
 
 ## Workflows
 
@@ -90,7 +90,7 @@ part of the input: a bare label list is a different, easier task.
 | `invoice_processing` | Review a vendor bill against the order and delivery to determine payment, hold or rejection. | 300 | 100 |
 | `security_incidents` | Decide whether a security alert should be closed, investigated, or contained, from alert data and machine history. | 300 | 100 |
 
-Each case asks **5 questions over one shared state**.
+Each case asks 5 questions over one shared state.
 
 ## Columns
 
@@ -98,19 +98,19 @@ Each case asks **5 questions over one shared state**.
 |---|---|
 | `id` | Case identifier |
 | `workflow` | Which workflow the case belongs to |
-| `state` | JSON. The unstructured state — the model's input |
+| `state` | JSON. The unstructured state, which is the model's input |
 | `questions` | JSON. The question set, with instructions and criteria |
 | `gold` | JSON. Full gold answers including every probability |
-| `factors` | JSON. Latent factors used to build the case. **For auditing only — not model input** |
+| `factors` | JSON. Latent factors used to build the case. Not model input |
 | `label_agreement` | JSON. Per question, how much the teacher samples disagreed |
 | `<question>__label` | Discrete gold answer |
 | `<question>__confidence` | Gold confidence, on the System One scale |
 | `<question>__probabilities` | JSON. Full gold distribution |
-| `<question>__score` | Expected score (`score` questions) |
-| `<question>__probability_true` | Probability of yes (`noul` questions) |
+| `<question>__score` | Expected score, for `score` questions |
+| `<question>__probability_true` | Probability of yes, for `noul` questions |
 
 `state` and `questions` together are exactly the body of a `POST /v1/systemone`
-request, so a row can be replayed without reshaping.
+request. You can replay a row without reshaping it.
 
 ## Usage
 
@@ -130,30 +130,31 @@ print(row["category__label"], row["category__confidence"])
 print(gold["urgency"]["probabilities"])   # distribution over rubric levels
 ```
 
-Scoring should use the **full distributions**, not just the argmax: the point of
-the benchmark is calibration. Report log loss, Brier score and ECE alongside
-accuracy.
+Score against the full distributions, not just the argmax. Calibration is the
+point. Report log loss, Brier score and ECE next to accuracy.
 
 ## How it was built
 
-1. **Latent skeleton sampled.** Each case starts from independently drawn
-   factors (topic, tone, tenure, severity, discrepancy type, whether a
-   constraint was violated, …) from spaces large enough that states essentially
+1. Sample a latent skeleton. Each case starts from independently drawn factors:
+   topic, tone, tenure, severity, discrepancy type, whether a constraint was
+   violated, and so on. The spaces are large enough that states essentially
    never repeat.
-2. **State rendered**, with free text written by a model conditioned on the
-   skeleton where the task is textual (customer threads, alert narratives) and
-   left structured where it genuinely is (invoices, agent traces).
-3. **Labelled by a teacher endpoint**, sampled 3 times per case at
-   temperature 0.7; the gold is the **mean of the sampled
-   distributions**. Averaging over distributions rather than argmax labels is
-   what makes the gold soft where the decision is genuinely ambiguous.
-4. **Audited before release** — see `AUDIT.md`.
+2. Render the state. Free text is written by a model conditioned on the
+   skeleton where the task is textual, as in customer threads and alert
+   narratives. It stays structured where the artefact genuinely is structured,
+   as in invoices and agent traces.
+3. Label it with a teacher endpoint, sampled 3 times per case at
+   temperature 0.7. The gold is the mean of the sampled
+   distributions. Averaging distributions instead of argmax labels is what
+   leaves the gold soft where a decision is genuinely ambiguous.
+4. Check before release: state diversity, label balance, and whether the gold
+   actually tracks the input.
 
 ## What a score here means
 
-Gold is the mean of three samples from a ~4B-class teacher endpoint, so a score
-measures **agreement with that teacher**, not correctness. Three reference points,
-all measured on these 400 cases:
+Gold is the mean of three samples from a teacher endpoint of roughly 4B-class
+capability. A score measures agreement with that teacher. It does not measure
+correctness. Three reference points, all measured on the 1600-case set:
 
 | Reference | Accuracy | What it is |
 |---|---|---|
@@ -161,93 +162,46 @@ all measured on these 400 cases:
 | Perfect scenario understanding | 0.704 | a model fitted to the latent factors that generated each case, cross-validated |
 | Teacher self-agreement | 0.735 | a fresh teacher sample scored against gold built from the others |
 
-**Read 0.52 as the floor, ~0.70 as strong, ~0.75 as saturation.** The factor
-ceiling sits *below* teacher self-agreement because the teacher shares its own
-idiosyncrasies with the gold and an outside model does not. A score much above
-0.75 means a model has learned the teacher's quirks rather than the task.
+Read 0.52 as the floor. Around 0.70 is strong. Around 0.75 is saturation.
 
-Per-question ceilings vary widely -- from 0.560 on `agent_trace/urgency` to
-0.937 on `customer_service/category` -- so every score should be read against
-its own question, not against the mean.
+The factor ceiling sits below teacher self-agreement. That is not a mistake. The
+teacher shares its own idiosyncrasies with the gold, and an outside model does
+not get that advantage. A score much above 0.75 means a model has learned the
+teacher's quirks rather than the task.
 
-A better model can score *worse*: anything right where the teacher is wrong is
-penalised. The teacher missed a duplicate invoice whose ID literally matched a
-prior one.
+Per-question ceilings vary a lot, from 0.560 on `agent_trace/urgency` to 0.937
+on `customer_service/category`. Read every score against its own question, not
+against the mean.
 
-## Two ways to be evaluated on this, and why it matters
+A better model can score worse here. Anything right where the teacher is wrong
+gets penalised. The teacher missed a duplicate invoice whose ID literally
+matched a prior one.
 
-The System One models this benchmark is shaped after are **general pretrained
-models**: their API exposes one call that takes an arbitrary question schema at
-request time, with no training step and no per-workflow setup. Anything scored
-here should say which of these it is, because the two are not comparable:
+## Two ways to be scored, and why the difference matters
+
+The System One models this benchmark is shaped after are general pretrained
+models. Their API is one call that takes an arbitrary question schema at request
+time. No training step, no per-workflow setup. Anything scored here should say which
+of the two modes it used. The two are not comparable.
 
 | | What it is | What it needs | Can it answer an unseen question? |
 |---|---|---|---|
-| **Specialist** | fitted per workflow, label spaces fixed at training time | training data for *these* workflows | No |
-| **Generalist** | one model, arbitrary question schemas, zero-shot | training data from *other* workflows | Yes |
+| Specialist | fitted per workflow, label spaces fixed at training time | training data for *these* workflows | No |
+| Generalist | one model, arbitrary question schemas, zero-shot | training data from *other* workflows | Yes |
 
-A specialist trained on these four workflows and scored on them is measuring
-**architecture** — how cheaply many typed decisions can be produced from one
-input. That is a legitimate question and this benchmark answers it well. It is
-*not* a comparison against a general System One model, which has never seen
-these workflows.
+Train a specialist on these four workflows, score it on them, and you have
+measured architecture: how cheaply many typed decisions can come out of one
+input. That is a real question and this benchmark answers it well. It is not a
+comparison against a general System One model, which has never seen these
+workflows.
 
 To be scored as a generalist, train on other workflows entirely and evaluate
-here zero-shot. Publish which mode you used; a specialist number next to a
-generalist number, unlabelled, is a misleading comparison.
-
-## Honest limitations
-
-**The gold is a teacher signal, not ground truth.** It comes from a model of
-roughly 4B-class capability, sampled three times and averaged. The benchmark
-measures how well a system reproduces that teacher's typed decisions — the
-distillation question a small decision model actually faces. It is **not** a
-claim that the teacher's answers are correct, and teacher errors are present:
-in the pilot it missed a duplicate invoice whose ID literally matched a prior
-one.
-
-**The states are synthetic.** They are built from sampled factors and generated
-text, not drawn from real support queues, SIEMs or accounts-payable systems.
-Results here describe architecture and systems behaviour, not real-world
-accuracy.
-
-**It is small.** 1600 cases, 8000 typed decisions -- all of them
-held out. Enough for decision-level metrics; thin for strong per-workflow claims.
-The generator is seeded and extensible, so the benchmark can grow without
-invalidating these cases.
-
-**Train and test are generated separately and verified disjoint.** The `test`
-split is the benchmark; the `train` split comes from a different seed with
-namespaced case ids. The packaging step checks that no case id and no state
-appears in both and refuses to build if either does -- that check exists because
-the v0.1 prototype leaked exactly this way and nobody noticed until models had
-already been benchmarked on it.
-
-## What the audit checks
-
-The **v1 prototype** failed in a way nothing caught until models had been benchmarked
-on it: its decisions were sampled independently of the input, so four of five
-questions were pure noise, and every input string appeared in all three splits.
-v2 gates on that:
-
-- **Diversity** — distinct states, and whether any repeat.
-- **Learnability** — mutual information between the gold and the known latent
-  factors, as a fraction of label entropy. Near zero is the v1 failure.
-- **Label balance** — whether a question collapses onto one answer, tested on
-  the Wilson lower bound so a rare-but-real event is not condemned by a small
-  sample.
-- **Stability** — how much the teacher samples disagreed per question.
-- **Softness** — how much gold mass sits away from the argmax, since all-one-hot
-  gold makes calibration untestable.
-
-Current audit: **0 flag(s)**.
-
-## Citation
-
-```bibtex
-@misc{typeddecisions,
-  title  = {Typed Decisions: a benchmark for typed probabilistic decisions over shared state},
-  year   = {2026},
-  url    = {https://huggingface.co/datasets/codelion/typed-decisions}
-}
-```
+here zero-shot. Say which mode you used. A specialist number sitting next to a
+generalist number, unlabelled, misleads the reader.
+
+## Splits
+
+Two splits, generated independently. `test` is the benchmark. `train` comes from
+a separate run at a different seed, with prefixed case ids. Packaging verifies
+that no case id and no state appears in both, and refuses to build if either
+does.