---
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}}
}
```