Datasets:
|
Download README.md from vkleban/SafeWorldProblems-Hard: direct link, hf CLI and curl.
- Browser
- Download file 16.2 kB
-
https://huggingface.co/datasets/vkleban/SafeWorldProblems-Hard/resolve/main/README.md
- Command line
-
hf download hf://datasets/vkleban/SafeWorldProblems-Hard/README.md
-
curl -L -o README.md https://huggingface.co/datasets/vkleban/SafeWorldProblems-Hard/resolve/main/README.md
16.2 kB
| license: cc-by-4.0 | |
| language: | |
| - en | |
| pretty_name: SafeWorldProblems-Hard | |
| size_categories: | |
| - 10K<n<100K | |
| task_categories: | |
| - text-classification | |
| - multiple-choice | |
| - question-answering | |
| tags: | |
| - synthetic | |
| - decision-making | |
| - reasoning | |
| - adversarial | |
| - evaluation | |
| configs: | |
| - config_name: numeric | |
| data_files: | |
| - split: validation | |
| path: data/numeric_validation-* | |
| - split: test | |
| path: data/numeric_test-* | |
| - config_name: non_numeric | |
| data_files: | |
| - split: validation | |
| path: data/non_numeric_validation-* | |
| - split: test | |
| path: data/non_numeric_test-* | |
| # SafeWorldProblems-Hard | |
| SafeWorldProblems-Hard is an evaluation set of 32,476 decision problems that an evolutionary search selected for | |
| difficulty. The search mutated questions and worlds to maximize the error of a commercial decision model, TypeSafe Jev | |
| 1.13.0, and sorted the results into four tiers: easy, middle, hard and ultrahard. A program computes every target, and | |
| an independent SQL engine verifies it, exactly as in | |
| [SafeWorldProblems](https://huggingface.co/datasets/vkleban/SafeWorldProblems). The reference model's answers, | |
| probabilities and errors are not part of the release; each example carries only its tier. | |
| Random samples from a generator measure average skill, and a strong model solves most of them. Hard cases cluster in | |
| specific compositions: reachability after a join, counts over filtered sets, negations inside relative clauses. An | |
| adversarial search steers toward those compositions instead of waiting for random sampling to hit them, and the tiers | |
| let any model's error profile be compared with the reference model's without exposing that model's outputs. | |
| This card gives the numbers at a glance and one complete ultrahard example. It then describes the format, the search | |
| that produced the data and the checks that keep the hard examples fair, and it closes with the recommended protocol and | |
| the limitations. Readers who know SafeWorldProblems can skip to the search and fairness sections. | |
| ## At a glance | |
| | property | value | | |
| | -------------- | ----------------------------------------------------------------------------------- | | |
| | examples | 32,476, each in two renderings (64,952 rows) | | |
| | tracks | `numeric` 18,318 examples, `non_numeric` 14,158 | | |
| | tiers | reference-model error: easy < 0.1, middle 0.1..0.5, hard 0.5..0.9, ultrahard >= 0.9 | | |
| | question types | numeric: noul 47%, choice 40%, score 13%; non_numeric: noul 75%, choice 25% | | |
| | program depth | mean 3.1..4.7 per tier and track | | |
| | row length | mean 1,219..1,366 tokens per tier (Qwen3 tokenizer) | | |
| | search | 173,005 requests scored by the reference model over 57 search restarts | | |
| | label check | an independent open model agrees with 97.9..100% of labels in every tier | | |
| | splits | validation and test, split by search lineage | | |
| | licence | CC BY 4.0 | | |
| ## Quickstart | |
| ```python | |
| from datasets import load_dataset | |
| hard = load_dataset("vkleban/SafeWorldProblems-Hard", "numeric", split="test") # or "non_numeric" | |
| ultra = hard.filter(lambda r: r["tier"] == "ultrahard") | |
| row = ultra[0] | |
| print(row["example_id"], row["rendering"], row["tier"]) | |
| print(row["state"]) | |
| q, t = row["questions"][0], row["targets"][0] | |
| print(q["instruction"]) | |
| print([c["description"] for c in q["candidates"]], t["target"]) | |
| ``` | |
| ## A worked example: an ultrahard count | |
| Example `swph-numeric-9b9cd07920a3ef07371d5ff7` describes a small infrastructure company: six devices, four teams, two | |
| engineers and seven data centers (701 tokens as Markdown tables). Two of its tables decide the answer, and the other | |
| five tables are distractors for this question. The two tables are: | |
| ```text | |
| Teams: | |
| | name | also called | budget (kEUR) | tier | | |
| | --- | --- | --- | --- | | |
| | TM-852 | TC-10 | 45 | gold | | |
| | TM-924 | - | 11 | gold | | |
| | TM-433 | TQ-62 | 36 | silver | | |
| | TM-532 | - | 3 | gold | | |
| Teams by engineer: | |
| | team | engineer | | |
| | --- | --- | | |
| | TM-433 | EN-356 | | |
| | TM-924 | EN-356 | | |
| | TM-532 | EN-356 | | |
| | TM-852 | EN-927 | | |
| ``` | |
| > Determine the count of the teams that the engineer in charge of team TM-924 leads that do not have a funding of at | |
| > least 11 kEUR. Nothing outside the given records exists. Counts are of distinct entries. | |
| The question is a choice over four candidates (0, 1, 2, 3), and its target is [0, 1, 0, 0]. The answer takes four | |
| steps. Team TM-924 is led by engineer EN-356, who leads TM-433 (36 kEUR), TM-924 (11 kEUR) and TM-532 (3 kEUR). Only | |
| TM-532 lacks a funding of at least 11 kEUR, so the count is 1. Three details add difficulty: the question says | |
| "funding" where the table says "budget", the boundary value 11 belongs to the subject team itself, and the negation | |
| sits inside a relative clause. | |
| The second rendering (`rendering` 1) states the same world as 85 triples such as `(Mustang, budget, 11 kEUR)`, with | |
| natural names in place of codes and the candidates in a new order. Its target is again the candidate "1". A model must | |
| answer both renderings correctly to solve the example. | |
| ## Format | |
| Each row holds one request in the SafeWorldProblems format: a `state`, one typed question and its verified target. | |
| Rows differ from the main dataset in three ways: every example appears twice, there are no bundles, and each row | |
| carries a tier. Fields shared with the main dataset keep their meaning. | |
| | field | meaning | | |
| | ------------------------------- | -------------------------------------------------------------------------------------------------------------- | | |
| | `id`, `example_id`, `rendering` | row id; the two renderings (0 and 1) of one example share `example_id` | | |
| | `track` | `numeric` or `non_numeric` | | |
| | `tier` | `easy`, `middle`, `hard` or `ultrahard` | | |
| | `split_name` | `validation` or `test` within the track | | |
| | `primitive`, `k` | question type (`choice`, `noul`, `score`) and candidate count | | |
| | `answer_type` | `int`, `bool`, `ent` (entity), `cat` (category), `opt` (may not exist, e.g. a path length), `outcome` (policy) | | |
| | `depth` | depth of the answer program | | |
| | `surface`, `wording` | rendering surface and wording module | | |
| | `state`, `state_format` | the records: plain text, or a JSON document serialized as a string | | |
| | `questions`, `targets` | as in SafeWorldProblems; `[P(true)]` for noul | | |
| | `tokens`, `state_tokens` | request and state length in Qwen3 tokens | | |
| The two renderings use a different surface in 83% of examples and a different wording module in 49%, and they draw | |
| entity names afresh. A model that solves one rendering and fails the other has learned a surface, not the question. | |
| Scoring both renderings therefore separates understanding from pattern matching. | |
| ## Tracks and tiers | |
| Two tracks separate arithmetic from structure. The `numeric` track allows counts, sums, differences, comparisons, | |
| dates, distances and extremes; the `non_numeric` track restricts answers and reasoning to joins, categories, relations, | |
| negation, sets, reachability and policies. Comparing a model's accuracy on the two tracks suggests how much of its error | |
| comes from arithmetic. | |
| | config | split | examples | easy | middle | hard | ultrahard | | |
| | ------------- | ---------- | -------: | ----: | -----: | ----: | --------: | | |
| | `numeric` | validation | 9,479 | 2,499 | 2,426 | 2,481 | 2,073 | | |
| | `numeric` | test | 8,839 | 2,409 | 2,420 | 2,372 | 1,638 | | |
| | `non_numeric` | validation | 7,542 | 2,488 | 2,534 | 1,934 | 586 | | |
| | `non_numeric` | test | 6,616 | 2,281 | 2,284 | 1,712 | 339 | | |
| A tier records the reference model's error on the example: one minus the probability it gave the correct answer, | |
| averaged over the two renderings. The search aimed for 5,000 examples per tier and track. Three tiers fell short | |
| within the search budget: numeric ultrahard (3,711), non-numeric hard (3,646) and non-numeric ultrahard (925). | |
| Difficulty concentrates in a few compositions. Ultrahard numeric requests are mostly counts (28%), lookups at the end | |
| of a chain (24%), path distances (16%) and extremes (15%). Ultrahard non-numeric requests are dominated by one-way | |
| reachability (52%), followed by selection of the unique entity matching a description (22%), lookups (13%) and policy | |
| decisions (11%). Mean program depth rises from 3.1 (numeric easy) to 4.7 (numeric ultrahard). | |
| ## How the search works | |
| The search is MAP-Elites with hill-climbing parents. It keeps an archive of the hardest requests found so far, one per | |
| cell, and breeds new requests from them. Every child is checked before the reference model sees it, so each scored | |
| request has a verified target. | |
| 1. **Individual.** One request: a sampled world, one typed program in the SafeWorldProblems language, a question type, | |
| a candidate count and a view (surface, naming, wording). | |
| 2. **Fitness.** The reference model's error on the request, averaged over two renderings, so a hit belongs to the | |
| request and not to one rendering. | |
| 3. **Archive.** Cells by question type, program depth, state length and answer type; a parent is the fitter of two | |
| random elites. | |
| 4. **Mutation.** Weighted operators regenerate a typed subtree (weight 3), add a conjunct or negation to a predicate | |
| (3), wrap a set in a filter (2), lift an entity to an attribute or a set to a count or an extreme (1.5), swap an | |
| operator (1.5), edit or grow the world (1 each), and change the view, question type or candidate count (0.5 each). | |
| Lineage crossover produces 30% of children. | |
| 5. **Checks.** Each child passes the generator's checks (types, definedness, candidate construction, state round trip, | |
| SQL oracle, token budget) before scoring. The validity rules of SafeWorldProblems, added one by one as the search | |
| exposed defects, were re-applied to every scored request before tiering. | |
| 6. **Diversity.** Children identical to an evaluated request are dropped. Later restarts (18 numeric, 12 non-numeric) | |
| also cap each seed lineage at 40 children per run and add 8 fresh seeds every generation. | |
| Each run started from 200 seed requests and bred 96 children per generation for 60 generations. Thirty numeric | |
| restarts scored 102,145 requests (96,673 distinct), and 27 non-numeric restarts scored 70,860 (65,336 distinct). A | |
| diversity sampler then filled the tiers, capping every program shape and every lineage at 2% of a tier, and requests | |
| that are equal up to renaming count once. | |
| ## Keeping hard examples fair | |
| An optimizer finds defects before it finds real weaknesses. Early runs reached high error with degenerate or misstated | |
| questions: a constraint that every candidate meets, a negation whose scope the English leaves open, a set operation that | |
| changes nothing. Each such exploit became a validity rule, and the final tiers exclude every request that breaks one. | |
| - **Validity rules.** Of 244,386 candidate requests, the rules removed 71,381 (29%), led by redundant constraints | |
| (25,413), redundant set operations (5,491) and repeated constraints (5,103). | |
| - **Vocabulary.** 1,073 examples whose state or question used a pair of conflatable category values (such as | |
| `restricted` and `closed`) were removed. | |
| - **Split by lineage.** Validation and test never share a search lineage, so relatives of one seed program stay on one | |
| side. | |
| - **Independent solver.** An open reasoning model, gpt-oss-120b, answered 400 random requests per tier as plain text. | |
| Its agreement with the labels: | |
| | track | easy | middle | hard | ultrahard | | |
| | ------------- | -----: | -----: | ----: | --------: | | |
| | `numeric` | 99.5% | 99.7% | 98.7% | 97.9% | | |
| | `non_numeric` | 100.0% | 99.5% | 97.9% | 98.1% | | |
| - **Final audit.** Two audit rounds replayed 100 examples (25 per track per round) and solved each with gpt-oss-120b | |
| and DeepSeek V4 Pro. All 100 replayed exactly and passed the validity rules; both solvers matched the label on 92, | |
| one solver on 5 and neither on 3. | |
| The agreement drops by at most two points from easy to ultrahard, while the reference model's error rises from below | |
| 0.1 to above 0.9. The ultrahard tier is therefore hard for that model, not ambiguous for careful readers. Every label | |
| in the set, including those the solvers miss, is confirmed by both engines. | |
| ## Recommended use | |
| SafeWorldProblems-Hard is an evaluation set. Its selection depends on a commercial model's behaviour, whose terms limit | |
| that model's outputs to evaluation, and training on test-selected data would also void the comparison. The protocol | |
| below keeps results comparable across models. | |
| - **Select** models on `validation` and report `test` once, per track and per tier. | |
| - **Score both renderings.** Report accuracy and cross-entropy per rendering, and the share of examples whose two | |
| renderings are both correct. | |
| - **Read tiers as relative.** A tier says how hard an example was for the reference model; compare a model's accuracy | |
| across tiers to see whether it shares that model's blind spots. | |
| - **Pair with SafeWorldProblems.** The main dataset's panels measure generalization under controlled shifts; this set | |
| measures robustness on compositions a strong model gets wrong. | |
| ## Limitations | |
| The set inherits the limits of SafeWorldProblems and adds the limits of adversarial selection. None of them affects the | |
| correctness of a target; they bound what a tier result means. Users should read tier results with both in mind. | |
| - **One reference model.** Tiers reflect Jev 1.13.0 only; another model, or a later Jev version, finds different | |
| requests hard. | |
| - **Skewed operator mix.** The search concentrates on the compositions where the reference model fails, so the mix of | |
| operators is not the mix of real workloads. | |
| - **Unequal tiers.** Numeric ultrahard (3,711), non-numeric hard (3,646) and non-numeric ultrahard (925) fall short of | |
| the 5,000 target. | |
| - **Generator version.** The requests come from generator v2.1 with its vocabulary; the v2.2 validity rules and the | |
| conflation filter were applied to them, but v2.2's renamed categories were not. | |
| - **Template English and small worlds.** As in the main dataset, the text is template-rendered and the worlds hold tens | |
| of entities; the language is English only. | |
| ## Version | |
| This is version 1.0, released in October 2026. The numeric track comes from the search preset `tiers_v1` (seed | |
| 20261100), and the non-numeric track from `tiers_nonnum_v1` (seed 20261200). Both searches scored requests against | |
| `jev-1.13.0`. | |
| ## Licence and citation | |
| The dataset is released under CC BY 4.0. It is fully synthetic and contains no third-party text and no model outputs; | |
| only the tier labels depend on the reference model. Please cite it as follows. | |
| ```bibtex | |
| @misc{kleban2026safeworldproblemshard, | |
| title = {SafeWorldProblems-Hard: Adversarially Evolved Decision Problems}, | |
| author = {Kleban, Vitaly}, | |
| year = {2026}, | |
| howpublished = {\url{https://huggingface.co/datasets/vkleban/SafeWorldProblems-Hard}} | |
| } | |
| ``` | |