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. 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

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:

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.

@misc{kleban2026safeworldproblemshard,
  title        = {SafeWorldProblems-Hard: Adversarially Evolved Decision Problems},
  author       = {Kleban, Vitaly},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/vkleban/SafeWorldProblems-Hard}}
}