Update dataset

README.md

@@ -25,10 +25,10 @@ A benchmark dataset for evaluating AI systems on challenging computer science pr
 
 ## Dataset Description
 
-This dataset contains 269 problems across three categories:
+This dataset contains 270 problems across three categories:
 - **Algorithmic**: 188 competitive programming problems with automated judging
 - **Research**: 66 open-ended research problems
-- **2.0**: 15 next-generation open-ended optimization problems
+- **2.0**: 16 next-generation open-ended optimization problems
 
 ## Dataset Structure
 

data/test-00000-of-00001.json

@@ -260,6 +260,7 @@
 {"problem_id": "erdos_demo", "category": "2.0", "statement": "# Erdos Unit Distance Demo\n\n## Problem\n\nPlace exactly `N = 10` distinct points in the Euclidean plane so that the\nnumber of point pairs at Euclidean distance exactly `1` is as large as possible.\n\nThis is a tiny, visually inspectable demo version of the planar unit distance\nproblem. If your construction naturally has a different common distance, scale\nthe coordinates before returning them.\n\n## Program Interface\n\nSubmit a Python file defining one of the following:\n\n```python\ndef solve(n: int) -> list[tuple[float, float]]:\n    ...\n```\n\nor:\n\n```python\ndef generate_points(n: int) -> list[tuple[float, float]]:\n    ...\n```\n\nor:\n\n```python\nPOINTS = [(0.0, 0.0), (1.0, 0.0), ...]\n```\n\nThe returned value must contain exactly 10 two-dimensional points. No stdin is\nused.\n\n## Validity Constraints\n\nA solution is valid if:\n\n1. It returns exactly 10 points.\n2. Every coordinate is a finite real number.\n3. No two points are closer than `1e-6`.\n\nThe objective is translation-invariant. Very large coordinates are allowed as\nlong as pairwise squared distances remain finite.\n\n## Objective\n\nFor all unordered point pairs, count those whose squared Euclidean distance is\nequal to `1` within a small floating-point tolerance. Let `M` be that count.\n\nMaximize `M`.\n\n## Scoring\n\nThe score is naturally scaled to `[0, 100)`, without clipping against a fixed\ntarget. Let:\n\n```text\nbaseline = N\nX = M\n```\n\nIf the point set is invalid, or if `X <= baseline`, the score is `0`. Otherwise:\n\n```text\nscore = 100 * (X - baseline) / X\n```\n\nThis makes the simple `N`-pair baseline worth `0`. With only 10 points, the\nproblem is intended as a quick sanity check and visual demo for agent workflows.\n", "config": "tag: geometry\nruntime:\n  language: python\n  timeout_seconds: 300\n  environment: \"Python 3.11; no external packages required\"\n  docker:\n    image: ubuntu:24.04\n"}
 {"problem_id": "erdos_unit_distance", "category": "2.0", "statement": "# Erdos Unit Distance\n\n## Problem\n\nPlace exactly `N = 65536` distinct points in the Euclidean plane so that the\nnumber of point pairs at Euclidean distance exactly `1` is as large as possible.\n\nThis is a finite, executable version of the planar unit distance problem:\ngiven `n` points, maximize the number of pairs at distance exactly `1`. If your\nconstruction naturally has a different common distance, scale the coordinates\nbefore returning them.\n\n## Program Interface\n\nSubmit a Python file defining one of the following:\n\n```python\ndef solve(n: int) -> list[tuple[float, float]]:\n    ...\n```\n\nor:\n\n```python\ndef generate_points(n: int) -> list[tuple[float, float]]:\n    ...\n```\n\nor:\n\n```python\nPOINTS = [(0.0, 0.0), (1.0, 0.0), ...]\n```\n\nThe returned value must contain exactly 65536 two-dimensional points. No stdin\nis used.\n\n## Validity Constraints\n\nA solution is valid if:\n\n1. It returns exactly 65536 points.\n2. Every coordinate is a finite real number.\n3. No two points are closer than `1e-3`.\n\nThe objective is translation-invariant. Very large coordinates are allowed as\nlong as pairwise squared distances remain finite.\n\n## Objective\n\nFor all unordered point pairs, count those whose squared Euclidean distance is\nequal to `1` within a strict floating-point tolerance. Let `M` be that count.\n\nMaximize `M`.\n\n## Scoring\n\nThe score is naturally scaled to `[0, 100)`, without clipping against a fixed\ntarget. Let:\n\n```text\nbaseline = N\nX = M\n```\n\nIf the point set is invalid, or if `X <= baseline`, the score is `0`. Otherwise\nthe raw score is:\n\n```text\nraw_score = 100 * (X - baseline) / X\n```\n\nThe reported score applies a cubic scale:\n\n```text\nscore = 100 * (raw_score / 100)^3\n```\n\nThis makes the simple `N`-pair baseline worth `0`, rewards every improvement\nabove the baseline, and keeps high-scoring constructions from saturating the\nbenchmark too quickly. The bounded and unbounded score fields both report this\ncubic-scaled score; evaluator messages also include `raw_score` for reference.\n", "config": "tag: geometry\nruntime:\n  language: python\n  timeout_seconds: 10800\n  environment: \"Python 3.11; no external packages required\"\n  docker:\n    image: ubuntu:24.04\n"}
 {"problem_id": "generals_io_bot", "category": "2.0", "statement": "# Generals.io Bot Arena\n\n![Generals.io gameplay](https://raw.githubusercontent.com/strakam/generals-bots/master/generals/assets/gifs/wider_gameplay.gif)\n\nImage credit: `strakam/generals-bots`, MIT license.\n\n## Problem\n\nImplement a bot for a local Generals.io-style arena. Your bot plays repeated\ntwo-player games against fixed baseline bots in the `generals-bots` simulator.\n\nYour goal is simple: protect your own general and capture the opponent's\ngeneral as often and as quickly as possible.\n\nEach game is played on a square grid with fog of war. If no general is captured\nbefore the truncation limit, the game is scored as a draw for win-rate purposes.\n\nThe environment is the local `generals-bots` simulator, not the online\ngenerals.io service. Each turn your bot receives an observation containing:\n\n```text\narmies, generals, cities, mountains, neutral_cells, owned_cells,\nopponent_cells, fog_cells, structures_in_fog, owned/opponent land and army\ncounts, and timestep\n```\n\n## Game Rules\n\nThe arena follows the local `generals-bots` simulator rules:\n\n- The grid contains passable empty cells, impassable mountains, neutral cities,\n  and one general per player.\n- You see every cell in the 3x3 neighborhood around your owned cells. Other\n  cells are fogged. Cities and mountains in fog may appear as\n  `structures_in_fog` obstacles.\n- Each turn both players choose one action. An action is either pass or move\n  from one owned source cell to one adjacent passable destination cell.\n- A non-split move sends `source_army - 1` armies and leaves one army behind.\n  A split move sends `source_army // 2` armies. Moves from cells with one army\n  are invalid and become no-ops.\n- Moving into your own cell reinforces it. Moving into neutral or enemy\n  territory is an attack. The attack captures the destination only when the\n  moving army is strictly larger than the defending army; the remaining army is\n  the absolute difference.\n- Capturing the enemy general immediately wins the game.\n- Army growth is deterministic: every owned cell gains one army when\n  `timestep % 50 == 0`, and owned generals/cities gain one army when\n  `timestep % 2 == 1`.\n- The default task setting uses 10x10 maps, truncates at 180 turns, and runs\n  one game per baseline matchup for quick iteration.\n\n## Submission\n\nSubmit a patch against the public `generals_agent` skeleton. In Harbor, edit the\nrepository under:\n\n```text\n/app/generals_agent\n```\n\nThen run:\n\n```bash\nbash /app/make_submission.sh\nbash /app/submit.sh\n```\n\nStart by submitting the baseline skeleton once before running long local\nexperiments. This establishes black-box feedback early; later submissions can\nreplace it as you improve the bot.\n\nThe patch must produce a Python module with:\n\n```python\nclass FrontierAgent:\n    def act(self, observation, key):\n        ...\n```\n\n`act` must return a `generals-bots` action array:\n\n```text\n[pass, row, col, direction, split]\n```\n\nwhere `direction` is `0=up`, `1=down`, `2=left`, `3=right`, and `split`\nselects whether to move half the army instead of all-but-one.\n\nPatches may modify only these files:\n\n```text\nbot.py\nstrategy.py\nutils.py\n```\n\nThe judge rejects binary patches, oversized patches, path traversal, and common\nfile/network/process access tokens. This is a bot-policy benchmark, not an\nenvironment inspection task.\n\nThe agent workspace intentionally does not include a Frontier-CS match runner,\nbaseline ensemble, hidden seeds, or evaluator implementation. Use the black-box\nsubmission interface for scoring feedback.\n\n## Scoring\n\nEvery submission is evaluated against the same baseline families used by final\nverification. These include random, expansion, hunting/pathing, and\nstrategy-inspired rule-based opponents, so exploiting only one weak bot is not\nenough for a high score. Faster wins also matter: the score gives substantial\ncredit for capturing the enemy general in fewer turns.\n\nThe default Harbor configuration is intentionally lightweight so agents can\niterate quickly: it uses one game per matchup and an internal evaluator time\nbudget. Increase `games_per_matchup`, `grid_sizes`, `truncation`, `pool_size`,\nand `max_eval_seconds` together in `config.yaml` for a heavier run. Adjust\n`speed_weight` if you want fast wins to matter more or less relative to raw win\nrate.\n\nPractical tip: the simulator is JAX-based. Simple array programs compile and\nrun much faster than large Python control-flow policies, so keep `act` compact\nand vectorized when possible.\n\nThe reported score is scaled to `[0, 100]`:\n\n```text\nscore = 100 * ((1 - speed_weight) * mean_baseline_win_rate + speed_weight * mean_baseline_speed_tiebreak)\n```\n\nThe default `speed_weight` is `0.25`. The speed credit is only earned on games\nthat your bot wins and is larger for earlier captures.\n\n## Notes\n\n- The online generals.io service is not used.\n- The hidden evaluator and hidden seeds are not visible in the agent workspace.\n- The task uses `strakam/generals-bots` at pinned commit\n  `c2b77bf72812ec91fb2024d80d90112b961dfa7e` under the MIT license.\n", "config": "tag: games\nruntime:\n  language: patch\n  timeout_seconds: 10800\n  environment: \"Generals.io bot patch; local generals-bots simulator arena\"\n  apt_packages:\n    - bash\n    - ca-certificates\n    - git\n    - python3\n    - python3-pip\n  judge_apt_packages:\n    - bash\n    - ca-certificates\n    - git\n    - python3\n    - python3-pip\n  docker:\n    image: frontiercs/generals-io-bot-agent:experimental-c2b77bf\n    judge_image: frontiercs/generals-io-bot-judge:experimental-c2b77bf\nenvironment:\n  cpus: 4\n  memory_mb: 8192\n  storage_mb: 8192\n  build_timeout_seconds: 1800\nevaluation:\n  generals_bots_commit: \"c2b77bf72812ec91fb2024d80d90112b961dfa7e\"\n  arena_seed: 20260608\n  games_per_matchup: 1\n  async_start_method: spawn\n  max_eval_seconds: 240\n  truncation: 180\n  pool_size: 2\n  speed_weight: 0.25\n  grid_sizes:\n    - 10\n  baselines:\n    - random_low_split\n    - expander\n    - strongest_frontier\n    - hunter\n    - fast_pathing\n    - flobot_fast\nsubmission:\n  kind: file\n  path: /app/solution.patch\n  allow_empty: true\n"}
+{"problem_id": "lwe_structured_recovery", "category": "2.0", "statement": "# Structured-LWE Public Witness Recovery\n\n## Goal\n\nRecover valid secret vectors for as many public structured-LWE instances as\nyou can.  For each instance, the public data define dimensions `n` and `m`, a\nmodulus `q`, a reproducible matrix `A`, a target vector `b`, public secret and\nerror distributions, and the exact predicates used for acceptance.  A valid\nsubmission satisfies the public relation\n\n```text\nb = A s + e (mod q)\n```\n\nwith a secret `s` and centered residual `e` that pass those predicates.  Any\nvalid `s` is accepted; you do not have to recover the particular witness used\nwhen the instance was generated.\n\n## Corpus\n\nThe production corpus has 200 public instances, split evenly across ten\nstructural families (20 per family):\n\n| Family | Public structure |\n| --- | --- |\n| `DS_BIN`, `DS_TER` | dense uniform matrix; exact-weight binary or signed-ternary secret |\n| `DS_SMALL` | dense uniform matrix; dense small-alphabet secret |\n| `SA_Q` | sparse matrix over general nonzero residues; unrestricted mod-`q` secret |\n| `SA_SMALL` | sparse small-alphabet matrix; unrestricted mod-`q` secret |\n| `DA_BIN`, `DA_TER` | dense binary or ternary matrix; unrestricted mod-`q` secret |\n| `MIX_Q_SPARSE` | sparse general-residue matrix and sparse small secret |\n| `MIX_SMALL_SPARSE` | sparse small-alphabet matrix and sparse small secret |\n| `MIX_DENSE_SMALL` | dense small-alphabet matrix and small or sparse small secret |\n\nThe public catalog deliberately omits difficulty labels, runtime bins,\ncalibration estimates, cryptanalysis paths, and reference solutions.  You\nshould treat the instance IDs as opaque names.  The intended workflow is\nincremental: inspect the public algebraic structure, try any attack strategy\nyou like, validate every candidate with the public facade, and submit each new\nsolution immediately while retaining all earlier ones.\n\n## Reproducibility\n\nEvery public record contains the complete matrix description, a SHAKE-256 seed\nand domain separator, inline `b`, all predicates, and an instance digest.  Thus\nany implementation can reconstruct `A` deterministically, and the catalog\nsidecar binds the exact JSONL bytes used by the evaluator.  The checked-in\nPython facade is the reference implementation; independent implementations\ncan be compared row-for-row against it.\n\nThe current production catalog SHA-256 is\n`318f32b68e8a30c6bcd5867c89eb10d87a5472614401f4e6df0f55356cdc98a6`.\nProduction witnesses and errors are sampled during corpus construction and must\nnot be retained as evaluator inputs or release assets.  Reproducibility means\nreproducing the public instance from its released record, not recovering any\nprivate generation seed.\n\n## Public catalog and stable Python interface\n\nThe packaged task contract uses these agent-visible paths:\n\n```text\n/app/public/catalog.jsonl       public instance catalog\n/app/public/lwe_instance.py     stable read-only Python facade\n/app/add_solution.py            cumulative-ledger helper\n/app/solution.json              submitted solution ledger\n/app/submit.sh                  submission command\n/app/wait_submission.sh         wait for one submitted UUID\n/app/submissions.sh             list submissions\n```\n\nThe production catalog contains exactly 200 instances.  Its entries and\nverified digest are authoritative.\n\nUse `public/lwe_instance.py`; callers do not need to import\n`lwe_challenge.*` or parse catalog JSON directly.  This complete example loads\nthe catalog, streams matrix rows, and checks a candidate:\n\n```python\nfrom pathlib import Path\nimport sys\n\npublic_dir = Path(\"/app/public\")\nsys.path.insert(0, str(public_dir))\n\nfrom lwe_instance import Catalog\n\ncatalog = Catalog.load(public_dir / \"catalog.jsonl\")\nprint(catalog.catalog_id, len(catalog.instances))\n\ninstance = catalog.instances[0]\nprint(instance.instance_id, instance.n, instance.m, instance.q)\nfirst_row = next(instance.iter_rows())\n\ncandidate = (0,) * instance.n  # replace with a candidate from your analysis\nverdict = instance.validate_secret(candidate)\nprint(first_row, verdict.ok, verdict.code)\n```\n\n`Catalog.instances` preserves public catalog order and `Catalog.get(id)` does\nlookup by ID.  Each immutable `Instance` exposes `n`, `m`, `q`, `b`, the matrix\nkind/seed/domain/alphabet/row weight, all public secret and error distribution\nparameters, all verifier bounds, and the instance digest.  It also provides:\n\n- `iter_rows()` to stream rows without materializing `A`;\n- `materialize_row_block(start, stop)` for a bounded row block;\n- `materialize_rows()` when the full public matrix fits your memory budget;\n- `matvec(secret)` for `A * secret mod q`; and\n- `validate_secret(secret)` for the exact public acceptance check.\n\nPrefer row streaming or blocks for large instances.\n\nThe declared matrix kinds are `uniform`, `small_alphabet`, `sparse_uniform`,\nand `sparse_small_alphabet`.  Secret-generation kinds are `uniform_mod_q`,\n`iid_alphabet`, `exact_weight_alphabet`, `balanced_exact_weight_signed`, and\n`centered_binomial`; error kinds are `truncated_discrete_gaussian`,\n`centered_binomial`, `bounded_uniform`, and `sparse_bounded`.  These labels and\nevery associated parameter are public.  The balanced signed plant uses an even\nexact weight and places equally many `-1` and `1` entries; its public acceptance\npredicate remains the separately declared alphabet and nonzero-weight range.\n\nThe facade property secret_alphabet is the acceptance alphabet.  For\nexact-weight secrets, the `exact_weight_alphabet` generation alphabet is\n`secret_alphabet` with zero removed because zero fills positions outside the\nexact support.  The `balanced_exact_weight_signed` plant specifically uses\n`{-1,1}` on its support even though the verifier also accepts any other vector\nmeeting the published signed alphabet and exact-weight predicate.  For the\nother alphabet-based kinds, `iid_alphabet` and `centered_binomial` generation\nand acceptance alphabets coincide.  The `uniform_mod_q` kind instead has no\nalphabet and uses all residues `0 <= s_j < q`.\n\n## Exact validity predicates\n\nFor one public instance, a submitted vector `s` is valid exactly when all of\nthe following hold:\n\n1. `len(s) == n`, and every component is a JSON/Python integer (booleans are\n   not integers for this contract).\n2. If `secret_predicate_kind == \"alphabet\"`, every component belongs to\n   `secret_alphabet`.  If it is `\"mod_q\"`, every component is in\n   `0 <= s_j < q`.\n3. The number of nonzero components is between `secret_min_nonzero` and\n   `secret_max_nonzero`, inclusive.\n4. Compute `p = A * s mod q`, then compute each canonical residual as\n   `r_i = center_q(b_i - p_i)`.  Equivalently, the evaluator computes\n   `center_q(b_i - (A s)_i)`.  The centered representative lies in\n   `[-floor(q/2), ceil(q/2) - 1]`.\n5. `max_i(abs(r_i)) <= error_max_abs`.\n6. When `error_max_l1` is not `None`,\n   `sum_i(abs(r_i)) <= error_max_l1`.\n7. When `error_max_l2_squared` is not `None`,\n   `sum_i(r_i * r_i) <= error_max_l2_squared`.\n8. When `error_max_nonzero` is not `None`, the number of nonzero residual\n   components is at most `error_max_nonzero`.\n\nThe public sampling-distribution fields are analysis inputs; acceptance is\ndetermined by the predicates above.  The evaluator holds no secret, planted\nanswer, private seed, or private error.  It reconstructs `A` from public data\nand checks only the submitted vector against public `(A, b)` and the public\npredicates.\n\nThe method validate_secret checks mathematical witness validity for one\nalready-selected instance.  At the submission boundary, ledger admissibility\nis a separate check covering the JSON/file limits, exact record shape, ID\nhandling, and duplicate rules below.  Thus an `ok` mathematical verdict does\nnot by itself make arbitrary ledger JSON admissible.\n\n## Cumulative JSON ledger\n\nThe only scored artifact is `/app/solution.json`.  Its strict schema is:\n\n```json\n{\n  \"schema_version\": 1,\n  \"solutions\": [\n    {\"instance_id\": \"example-id\", \"secret\": [1, 0, -1]}\n  ]\n}\n```\n\nThe whole-file rules require an unambiguous UTF-8 JSON object whose top-level\nfields are exactly `schema_version` and `solutions`, with integer\n`schema_version == 1` and a `solutions` array of at most 200 elements.  No JSON\nobject may repeat a key, and the encoded file may contain at most 2,000,000\nbytes.  The decoder also permits at most 4 levels of JSON nesting and 820,205\ndecoded nodes.  Exceeding either decoder budget is a whole-file\n`invalid_json` error; for example, a nested secret such as `[[0]]` is rejected\nbefore per-record validation.  Therefore, violating a whole-file rule scores\nzero even when another record is valid.\n\nRecords are checked separately.  A canonical record has exactly `instance_id`\nand `secret`; the ID matches `[A-Za-z0-9][A-Za-z0-9._-]{0,63}` and names a\npublic instance, while `secret` is an integer array whose components have\nabsolute value at most `2^63 - 1` and whose length is at most 4,096.  A\nper-record rejection does not invalidate the whole ledger; unrelated valid\nrecords can still score; the canonical empty ledger is pre-provisioned at\n/app/solution.json as:\n\n```json\n{\"schema_version\":1,\"solutions\":[]}\n```\n\nUse the locked, atomic cumulative helper instead of rebuilding the file:\n\n```bash\npython3 /app/add_solution.py INSTANCE_ID '1,0,-1'\n```\n\nThe helper reads `/app/solution.json`, retains its prior records, adds the new\nrecord, writes canonical sorted JSON atomically, and prints the resulting\nrecord count.  An identical existing witness is an idempotent no-op.  A\ndifferent existing witness is rejected unless you pass --replace explicitly:\n\n```bash\npython3 /app/add_solution.py --replace INSTANCE_ID '0,1,-1'\n```\n\nA successful add_solution exit and write enforces canonical structural ledger\nrules: exact object fields and version, unique regex-valid IDs, integer arrays\nof at most 4,096 bounded components, and the 200-record and 2,000,000-byte\ncaps.  The helper refuses an update that would exceed the 200-record or\n2,000,000-byte cap, as well as either component bound.\nSuccess does not prove catalog membership or mathematical witness validity\nbecause the helper does not load the catalog.  Validate with\n`instance.validate_secret(candidate)` before adding a record.  After every\nsuccessful helper call, the ledger remains cumulative.\n\nDuplicate handling by the evaluator is deliberately strict: every repeated\nsafe instance_id invalidates every occurrence for that ID, even when the\nvectors are identical or one occurrence is malformed.  That ID earns no point.\nHere safe means syntactically valid under the instance-ID regex; it does not\nmean that the ID occurs in the public catalog.  duplicate_count counts distinct\nsyntactically valid IDs that occur more than once, not duplicate occurrences.\nconflict_count counts distinct IDs with more than one distinct syntactically\nvalid integer vector, not conflicting pairs or occurrences.  Here a\nsyntactically valid integer vector is a JSON array of non-boolean integers\nwithin the ledger integer bound and at most 4,096 components; it need not have\nthe right dimension or pass the mathematical witness predicates.  Every\nrejected occurrence contributes to `invalid_count`.\n\nunknown_count counts distinct regex-valid IDs absent from the catalog, even\nwhen an ID is repeated or another field in its record is malformed.  This set\ncount is independent of the per-occurrence rejection code.  unknown_instance_id\napplies only to a unique otherwise syntactically admissible record.  For a\nunique admissible record, a syntactically valid but unknown instance_id is a\nper-record `unknown_instance_id` rejection.  invalid_record_fields takes\nprecedence for a unique malformed unknown when its record fields are wrong.\nWith exact fields but a malformed secret, invalid_secret takes precedence for\na unique malformed unknown over the unknown-ID code.  For repeated IDs,\nduplicate_instance_id takes precedence for every occurrence of a repeated ID.\nThe helper normally prevents duplicate records; use `--replace` instead of\ncreating a second JSON record.\n\n## Scoring and public feedback\n\nEvery catalog instance has equal weight.  Let `solved_count` be the number of\nunique instance IDs whose submitted secret passes all predicates, and let\n`instance_count` be the catalog size:\n\n```text\nscore = 100 * solved_count / instance_count\nscore_unbounded = solved_count\n```\n\nAn invalid record does not erase unrelated valid records.  Whole-ledger format\nerrors score zero, so keep the helper-produced ledger intact.\n\nThe public feedback contains the bounded `score`, count-valued\n`score_unbounded`, a sanitized summary message, and aggregate metrics.  Metrics\ninclude `instance_count`, `solved_count`, `submitted_count`, `invalid_count`,\n`duplicate_count`, `conflict_count`, `unknown_count`,\n`rejection_code_counts`, `invalid_examples`, and `solved_ids`.  Feedback never\ncontains difficulty labels, runtime bins, family buckets, submitted vectors,\nresiduals, private values, filesystem paths, tracebacks, or exception text.\n\n## Iterate and submit cumulatively\n\nAlways submit after every newly validated secret for a previously unsolved\ninstance, or after a score-changing replacement; do not wait to finish a\nbatch.  Always retain all prior entries in `/app/solution.json`.\n\nSubmission is asynchronous.  Running `bash /app/submit.sh` snapshots and queues\nthe current `/app/solution.json` and prints a submission UUID:\n\n```bash\nbash /app/submit.sh\n```\n\nSave that UUID, then wait for its result with:\n\n```bash\nbash /app/wait_submission.sh SUBMISSION_UUID\n```\n\nList submissions when you need to recover an ID or inspect status:\n\n```bash\nbash /app/submissions.sh\n```\n\nThe submit command does not return evaluator feedback.  Plain\n`submissions.sh` gives a status and score summary, while `wait_submission.sh`\nprints the completed score, message, and metrics.  Add `--json` to either wait\nor list when you need the complete structured submission record.  The adapter\nallows at most 3 pending submissions.  Use each completed public response to\nguide the next analysis, and submit again whenever the cumulative ledger\nimproves.\n\n## Resource budget\n\nThe configured environment is CPU-only and provides:\n\n- Ubuntu 24.04 with its distro Python 3.12 runtime;\n- 8 CPU cores;\n- 32 GiB memory;\n- 32 GiB storage;\n- 10,800 seconds (3 hours) of task runtime;\n- 1,800 seconds (30 minutes) of build time;\n- Ubuntu's generic `fplll-tools` package and standard build dependencies.\n\nDo not rely on a GPU.\n", "config": "tag: security\nruntime:\n  language: python\n  timeout_seconds: 10800\n  environment: \"Public structured-LWE instances; Python 3.12 helper library; CPU only\"\n  apt_packages:\n    - build-essential\n    - ca-certificates\n    - fplll-tools\n    - git\n    - libgmp-dev\n    - libmpfr-dev\n    - pkg-config\n    - python3\n    - python3-dev\n  docker:\n    image: ubuntu:24.04\nenvironment:\n  cpus: 8\n  memory_mb: 32768\n  storage_mb: 32768\n  build_timeout_seconds: 1800\nsubmission:\n  kind: file\n  path: /app/solution.json\n  max_queue_size: 3\n"}
 {"problem_id": "nanowm_rollout_speedup", "category": "2.0", "statement": "# NanoWM Rollout Speedup — fast diffusion sampling for a frozen video world model\n\n## Problem\n\nYou are given a clean checkout of **Nano World Models** (arXiv:2605.23993) and\nits frozen **NanoWM-L/2 CSGO** checkpoint — a diffusion-forcing video world model.\nThe judge runs a **fixed** autoregressive long-rollout: from 4 context frames,\ngenerate **50 future frames** of held-out CSGO gameplay, sequential scheduling,\nnominal **50 DDIM steps**.\n\nYour job: **make that rollout faster** by submitting a **Python-only patch** to\nthe diffusion **sampling** code, **without degrading rollout quality**. Score is\nwall-clock speedup over the unpatched baseline, gated by a quality guardrail.\n\nThis is a real fast-sampling problem: the paper's Fig. 6 shows DDIM step count\ngenuinely trades off against rollout quality on CSGO (unlike saturated toy\ndomains). Naively cutting steps degrades quality and fails the guardrail; to win\nyou must reproduce ~50-step quality with less compute — DPM-Solver++ / higher-order\nor exponential integrators, KV/feature caching across denoising steps and frames,\nmixed precision, `torch.compile`, fused attention, redundancy elimination, etc.\n\n## What you submit\n\nA unified-diff patch at **`/app/solution.patch`** against the checkout in\n`/app/nano-world-model`. **Python source only**, and only within the diffusion\nsampling layer:\n\n**Allowed:** `src/diffusion/**.py`, `src/sample/sampling_utils.py`\n**Denied:** the model architecture (`src/models/**`), VAE (`src/latent_codecs/**`),\nthe metric (`src/sample/evaluate_metrics.py`), the rollout harness\n(`src/sample/rollout.py`), data loading (`src/wm_datasets/**`), training/eval\nharness, and any native/build/dependency files. New `.py` files inside the\nallowed areas are fine. Patches are validated **before** running.\n\nThe rollout invocation (length, context, nominal step count, scheduling) is\n**fixed by the judge** — you change the sampler internals, not the call. Patches\nthat read judge/Modal/HF env vars, hard-code episode ids or ground truth,\nshort-circuit/sleep, or special-case the benchmark are rejected.\n\n## Evaluation & scoring\n\n- The judge applies your patch to a clean checkout and runs the fixed CSGO\n  rollout on hidden held-out episodes on a **GPU (served via Modal)**. Iterative\n  (`bash /app/submit.sh`) uses a small quick set; the final verifier uses a\n  larger disjoint set.\n- **Quality guardrail:** rollout **LPIPS vs ground truth** must not rise more\n  than `quality_tolerance` (default **3%**) above the unpatched seq@50 baseline.\n  (Calibration: seq@20 is already +5% over seq@50, so naive step-cutting fails\n  this — real fast-sampling is required.)\n- **Score:**\n\n```\ngeomean_speedup = baseline_seconds / patched_seconds   (rollout generation)\nscore           = clip(100 * log2(geomean_speedup), 0, 100) * quality_multiplier\n```\n\n  `quality_multiplier` is 1.0 within tolerance and decays inverse-proportionally\n  beyond it. `score_unbounded` keeps rewarding speedup past 2× (the bounded score\n  caps at 100). A patch that degrades quality past tolerance is penalized toward\n  0; one that crashes, exceeds limits, or violates the patch policy scores 0.\n\n## Resource budget\n\nCPU agent + judge containers (8 CPU / 32 GB); one Modal GPU per evaluation.\nEvaluation timeout 21600 s. Submission queue depth 2.\n\n## Getting started\n\n`/app/nano-world-model` is the checkout you patch. `bash /app/public_test.sh`\nruns a tiny local policy check on your `solution.patch`. See `AGENT.md` and\n`harbor/app/README.md` for the submission workflow, and the paper / `docs/` for\nthe sampling code you'll be optimizing (`src/diffusion/df_sample.py`,\n`gaussian_diffusion.py`).\n", "config": "tag: systems\nruntime:\n  # Submission is a Python-only source patch (the real reference is\n  # reference.patch). `language: python` keeps the file extension/CLI conventions\n  # standard (mirrors vllm_llm_serving_optimization, #145); there is no separate\n  # \"patch\" language in the framework.\n  language: python\n  timeout_seconds: 21600\n  environment: >-\n    Python-only patch against a clean NanoWM checkout (Nano World Models,\n    arXiv:2605.23993); Modal GPU runs the NanoWM-L/2 CSGO 50-frame long-rollout;\n    speedup-vs-baseline judge with an LPIPS rollout-quality guardrail\n  apt_packages:\n    - bash\n    - ca-certificates\n    - curl\n    - git\n    - python3\n    - python3-pip\n  judge_apt_packages:\n    - bash\n    - ca-certificates\n    - curl\n    - git\n    - python3\n    - python3-pip\n  judge_pip_packages:\n    - modal\n  docker:\n    # Experimental local images; build with docker/build_images.sh before a local\n    # Harbor trial. Both bake a clean NanoWM checkout + the L/2 CSGO ckpt; the\n    # judge image additionally vendors the held-out CSGO episode subset, the\n    # LPIPS scorer, and the cached vanilla baseline metrics.\n    image: frontiercs/nanowm-rollout-speedup-agent:experimental-v0\n    judge_image: frontiercs/nanowm-rollout-speedup-judge:experimental-v0\nenvironment:\n  cpus: 8\n  memory_mb: 32768\n  storage_mb: 32768\n  build_timeout_seconds: 5400\nevaluation:\n  # GPU served on Modal (one per environment); judge container is CPU-only.\n  # H100 matches the hardware the reference + noise floor were calibrated on, so\n  # the production scoring path and the validated numbers share one GPU SKU.\n  model: nanowm_l2_csgo\n  dataset: game/csgo\n  gpu: H100\n  # FIXED rollout invocation (the agent's patch changes sampler internals, not these).\n  rollout_length: 50\n  history_length: 4\n  num_steps: 50            # nominal reference DDIM budget\n  scheduling: sequential\n  history_stab: 0.02\n  # Quality guardrail: patched rollout LPIPS-vs-GT may rise at most this\n  # (relative) above the unpatched seq@50 baseline before the score is penalized.\n  # Calibrated: seq@20 is already +5% over seq@50, so a 3% tolerance forces real\n  # fast-sampling work (DPM-Solver++, caching, distillation), not naive step cuts.\n  quality_tolerance: 0.03\n  # (E) Speedup at which the latency score saturates to 100: score is\n  # 100*log2(speedup)/log2(target). The old bare 100*log2 capped everything >=2x\n  # at 100; 4x keeps a gradient across the achievable range (causal-prefix ~3x).\n  speedup_target: 4.0\n  # (A) Faithfulness BACKSTOP: mean LPIPS between PATCHED and BASELINE rollout\n  # frames (paired final run), always reported; penalty only past this generous\n  # threshold so it catches an egregious rollout SUBSTITUTION, not legitimate\n  # iso-quality speedups. Calibrated on H100: bf16 reference drifts 0.206 from the\n  # fp32 baseline (iso-quality vs GT, different trajectory), so 0.30 clears it with\n  # margin while still flagging ~half-divergent substitutions; causal-prefix ~0.\n  faithfulness_tol: 0.30\n  quick_clips: 4           # iterative (agent-role) public feedback\n  final_clips: 16          # final (verifier-role) evaluation\n  batch_size: 4\n  # Key MUST be `baseline_cache` (settings.py strips the FRONTIER_NWM_ prefix and\n  # looks up `baseline_cache`); `baseline_cache_path` was silently ignored.\n  baseline_cache: /opt/nanowm/baseline/baseline_metrics.json\nsubmission:\n  kind: file\n  path: /app/solution.patch\n  max_queue_size: 2\n"}
 {"problem_id": "nanowm_rollout_stability", "category": "2.0", "statement": "# NanoWM Rollout Stability — minimize long-horizon drift at fixed compute\n\n## Problem\n\nYou are given a clean checkout of Nano World Models (arXiv:2605.23993) and its\nfrozen NanoWM-L/2 CSGO checkpoint. The judge runs a **fixed long-horizon**\nautoregressive rollout (sequential, **50 DDIM steps**). Long autoregressive\nrollouts accumulate perceptual error — by the tail of the rollout the prediction\nhas drifted into a \"plausible but wrong\" state (paper Finding #5).\n\nYour job: **minimize that drift** — the mean LPIPS-vs-ground-truth over the\n**drifted tail frames** (the late portion of the rollout) — by submitting a\n**Python-only patch** to the diffusion **sampling** code, **without using more\ncompute** (a wall-clock budget = the unpatched baseline's generation time is\nenforced).\n\nThe exact rollout length and which frames are scored as the \"tail\" are fixed by\nthe judge and **not disclosed** — the scored horizon is drawn per run — so a\nsolution must reduce drift **generally**; keying behaviour off an assumed rollout\nlength or a hardcoded frame index will not transfer to the scored run.\n\nThis is a hard, open problem: simply adding denoising steps reduces drift but is\ndisallowed (it costs compute — that's the *speedup* task). At fixed compute you\nmust use the budget *smarter*: history stabilization, scheduling-matrix design,\ndrift-aware KV/feature caching that frees time for re-grounding, periodic\ncontext re-anchoring, error-feedback correction, better solvers, etc.\n\n## What you submit\n\nA unified-diff patch at `/app/solution.patch` against `/app/nano-world-model`.\n**Python source only**, within the diffusion sampling layer:\n**Allowed:** `src/diffusion/**.py`, `src/sample/sampling_utils.py`.\n**Denied:** model (`src/models/**`), VAE, the metric, the rollout harness\n(`src/sample/rollout.py`), data loading, training/eval harness, native/build\nfiles. No env-var/benchmark/timing tricks. Validated before running.\n\n## Evaluation & scoring\n\n- Judge applies your patch, runs the fixed long-horizon CSGO rollout on hidden\n  episodes (Modal GPU), measures **tail-drift** (mean LPIPS-vs-GT over the late /\n  tail frames) and **generation wall-clock**. Quick set for iterative `submit.sh`;\n  a larger disjoint set for the final verifier (enough clips to resolve small drift\n  reductions above per-clip noise). The exact rollout length and tail window are\n  not disclosed and vary per scored run.\n- **Score:**\n\n```\nscore = clip(100 * (baseline_tail_drift - patched_tail_drift) / baseline_tail_drift, 0, 100)\n        * wallclock_multiplier\n```\n\n  `wallclock_multiplier` is 1.0 while patched generation time stays within 10%\n  of the baseline, and decays beyond (so you cannot buy drift reduction with\n  more compute). A patch that does not reduce drift, exceeds the wall-clock\n  budget, crashes, or violates the patch policy scores 0.\n\n## Reference & difficulty\n\n`reference.patch` raises history stabilization (a one-line sampling change) — it\nreliably reduces tail-drift ~6.8% (± 1.2%) over the baseline at iso-wall-clock\n(validated under common-random-numbers pairing: 74% per-clip win, pooled paired\nt=5.15, p<1e-4 across 3 seeds × 22 clips), proving the task is solvable.\nSubstantially beating it is the open challenge.\n\n## Resource budget\n\nCPU agent + judge; one Modal GPU per evaluation. Evaluation timeout 21600 s.\nSee `AGENT.md` and `harbor/app/README.md`.\n", "config": "tag: systems\nruntime:\n  # Submission is a Python-only source patch (the real reference is\n  # reference.patch). `language: python` keeps the file extension/CLI conventions\n  # standard (mirrors vllm_llm_serving_optimization, #145); there is no separate\n  # \"patch\" language in the framework.\n  language: python\n  # 12h. The scored final is a 22->12-clip baseline+patched PAIR of 80-frame\n  # rollouts under strict determinism (TF32 off ~3x slower): ~5-7h on H100. The\n  # old 6h verifier timeout was SHORTER than the final run, so the verifier raised\n  # VerifierTimeoutError -> reward 0 even though the agent submissions scored fine.\n  # Matches the Modal _rollout_pair function timeout (43200s).\n  timeout_seconds: 43200\n  environment: >-\n    Python-only patch against a clean NanoWM checkout (Nano World Models,\n    arXiv:2605.23993); Modal GPU runs a NanoWM-L/2 CSGO long-horizon rollout (the\n    exact length and scored tail are fixed by the judge and not disclosed);\n    minimize long-horizon drift (tail-frame LPIPS) at iso-wall-clock\n  apt_packages: [bash, ca-certificates, curl, git, python3, python3-pip]\n  judge_apt_packages: [bash, ca-certificates, curl, git, python3, python3-pip]\n  judge_pip_packages: [modal]\n  docker:\n    image: frontiercs/nanowm-rollout-stability-agent:experimental-v0\n    judge_image: frontiercs/nanowm-rollout-stability-judge:experimental-v0\nenvironment:\n  cpus: 8\n  memory_mb: 32768\n  storage_mb: 32768\n  build_timeout_seconds: 5400\nevaluation:\n  # H100 matches the hardware the reference + noise floor were calibrated on, so\n  # the production scoring path and the validated numbers share one GPU SKU.\n  model: nanowm_l2_csgo\n  dataset: game/csgo\n  gpu: H100\n  # LONG rollout so error accumulates into a drifted tail; FIXED steps + a\n  # wall-clock budget => the agent improves the rollout PROCEDURE at iso-compute\n  # (stabilization / scheduling / drift-aware caching), not by adding steps.\n  rollout_length: 80       # NOMINAL: agent-role QUICK loop + cache fingerprint\n  history_length: 4\n  num_steps: 50            # fixed compute budget\n  scheduling: sequential\n  history_stab: 0.02       # baseline default (repo long_rollout setting)\n  drift_tail_start: 60     # NOMINAL tail (cached agent path); scored tail derives from the randomized horizon\n  # Anti-overfit (audit #7): the SCORED (role=final) horizon is drawn at random per\n  # run from [rollout_length_min, rollout_length_max] (MAX < nominal so the agent's\n  # dev-measured horizon never scores, and GT headroom/clip-count are unchanged), and\n  # the scored tail = horizon - tail_frames. This neutralizes the codex module-counter\n  # tail-targeting hack (its period 76 / frame-64 ramp misfire off the tail at <=72;\n  # see stability_eval/test_antihack_horizon.py). Tune to trade anti-hack margin vs\n  # SNR (lower max = stronger anti-hack; raise toward 80 = closer to calibrated tail>=60).\n  rollout_length_min: 64\n  rollout_length_max: 72\n  tail_frames: 20\n  # Wall-clock guardrail: patched gen time may rise at most this over baseline,\n  # else drift is being bought with compute (the speedup task's axis).\n  wallclock_tolerance: 0.10\n  # Drift reductions are small; enough clips to resolve above per-clip noise\n  # (validated under common-random-numbers pairing: stab=0.20 reference beats\n  # baseline; 74% per-clip win, pooled paired t=5.15, p<1e-4 across 3 seeds x 22 clips).\n  quick_clips: 8\n  # Full held-out set = the 22 test_split episodes number<=200 staged from the\n  # 1-200 chunk (>22 indexes past the sliced dataset and crashes). The scored final\n  # uses all 22 for SNR (validated headline). The 80-frame paired rollout is ~10h\n  # sequentially under strict determinism, so the judge FANS the clips out across\n  # Modal containers (chunk_size each) -- bit-identical to the sequential run since\n  # the per-batch seed keys on the global clip index -- finishing in ~one chunk's\n  # wall-time. batch_size=2 => QUICK(8) is a noise-identical prefix of FINAL(22).\n  final_clips: 22\n  batch_size: 2\n  # Clips per Modal container in the fanned-out scored pair (rounded up to a\n  # multiple of batch_size for global batch alignment). 22/4 => 6 parallel chunks.\n  chunk_size: 4\n  # Key MUST be `baseline_cache` (settings.py strips the FRONTIER_NWM_ prefix and\n  # looks up `baseline_cache`); `baseline_cache_path` was silently ignored.\n  baseline_cache: /opt/nanowm/baseline/stability_baseline.json\nsubmission:\n  kind: file\n  path: /app/solution.patch\n  max_queue_size: 2\n"}
 {"problem_id": "rocksdb_native_compaction_policy", "category": "2.0", "statement": "RocksDB Native Compaction Policy\n\nGoal\n\nImprove leveled compaction selection in RocksDB v10.10.1 while preserving database correctness. The workspace contains the pinned source tree at /app/rocksdb. The judge applies your patch to a clean checkout at commit 4595a5e95ae8525c42e172a054435782b3479c57, rebuilds RocksDB, and compares it with the unmodified build.\n\nWorkload\n\nThe judge runs native RocksDB workloads with changing write, point-read, scan, range-delete, snapshot, time-series, and multi-column-family phases. Options such as write-buffer size, L0 thresholds, level sizes, value sizes, and cache size vary by case. Leveled compaction is always used; universal and FIFO compaction are outside this task.\n\nFeedback uses one fixed development case per workload family plus a smoke case. Final verification uses two fixed judge-derived seeds per family. Final seeds are not included in the agent workspace or task configuration.\n\nSubmission\n\nSubmit /app/solution.patch. After editing the checkout, run:\n\n  bash /app/make_submission.sh\n  bash /app/submit.sh\n\nmake_submission.sh rejects changes outside the editable surface instead of silently omitting them. An empty patch is a valid zero-score baseline.\n\nEditable surface\n\n  db/compaction/compaction_picker.cc\n  db/compaction/compaction_picker.h\n  db/compaction/compaction_picker_level.cc\n  db/compaction/compaction_picker_level.h\n  db/version_set.cc\n\nThe task covers leveled compaction selection: choosing levels and files, computing file priority, handling L0 pressure, intra-L0 decisions, marked files, tombstone-driven picks, and picker expansion. Output-file cutting is not part of the editable surface.\n\nCorrectness\n\nCorrectness is a hard gate. The candidate must build and complete every case without crash, timeout, deadlock, or background error. The harness checks point reads, range deletes, held snapshots, column families, database reopen, and a complete iterator comparison against its logical oracle.\n\nPatches may not inspect judge identity, paths, environment variables, process state, clocks, profile names, or infrastructure details. New preprocessor directives and changes outside the five listed files are rejected. Submitted binaries and local benchmark output are ignored.\n\nScoring\n\nEach case runs one isolated vanilla/candidate pair concurrently on the same deterministic operation stream. Final verification uses two seeds per workload family. The case objective is a weighted geometric mean of lower-is-better ratios:\n\n  40% write amplification\n  25% read amplification\n  20% pre-drain space amplification\n  15% trusted compaction output required after the policy run\n\nThe initial database load is compacted through a fixed manual path, fingerprinted, and excluded from scored counters. A candidate that changes this base state is invalid. Later writes and compactions run in fixed phase-boundary cycles so each picker decision starts from a reproducible state. Pre-drain memtables are flushed, actual table-file bytes are measured, and metadata is captured while background work is paused. After each policy run closes, an unmodified judge binary reopens the database and runs the normal vanilla policy until an additional pass produces no compaction output. It verifies the logical data before and after this residual drain. Trusted residual output is added to write amplification, and the policy plus residual drain is scored separately as 1 + output bytes divided by the larger of user-write bytes and 64 MiB, so deferred work cannot lower the measured cost. Final score uses the mean paired log improvement with a small cross-case dispersion penalty. Robust gains at or below 1.005x are treated as measurement noise and earn zero; a robust 1.017x aggregate reaches 100. Invalid or failed submissions score zero and report a strongly negative unbounded score, so they always rank below valid submissions. A positive score requires at least 40% and at least two workload families to improve by 0.5% or more, and at most one family may regress by more than 2%. Severe per-case or per-metric regressions reduce or cap the score. Extreme runtime or stall regressions are validity guards; otherwise wall-clock throughput, latency, and stall time are diagnostics, not score terms.\n\nFeedback exposes validity, build status, aggregate gain, worst-case gain, component floor, workload breadth counts, average intra-L0 decision delta per case, case count, and a coarse score band. It does not expose per-case metrics, seeds, or final profile order.\n\nResources\n\n  vCPUs: 8\n  memory: 16 GiB\n  storage: 32 GiB\n  build timeout: 7200 seconds\n  per-run timeout: 1800 seconds\n", "config": "tag: systems\nruntime:\n  language: cpp\n  timeout_seconds: 10800\n  environment: \"Patch a pinned RocksDB v10.10.1 checkout; native correctness and compaction-cost judge\"\n  apt_packages:\n    - bash\n    - build-essential\n    - ca-certificates\n    - git\n    - libbz2-dev\n    - libgflags-dev\n    - liblz4-dev\n    - libsnappy-dev\n    - libzstd-dev\n    - zlib1g-dev\n  docker:\n    image: python:3.12-slim-bookworm\n    judge_image: frontiercs/rocksdb-native-compaction-judge:experimental-v10.10.1-task2\n  visible_inputs:\n    - source: /opt/rocksdb-clean\n      destination: /app/rocksdb\nenvironment:\n  cpus: 8\n  memory_mb: 16384\n  storage_mb: 32768\n  build_timeout_seconds: 7200\nevaluation:\n  schema_version: rocksdb-native-compaction-v2\n  public_suite_id: rocksdb-native-public-v2\n  final_suite_id: rocksdb-native-final-v2\n  rocksdb_commit: \"4595a5e95ae8525c42e172a054435782b3479c57\"\n  feedback_cases:\n    - {seed: 1101, profile: smoke}\n    - {seed: 1202, profile: l0_pressure}\n    - {seed: 1303, profile: range_snapshot}\n    - {seed: 1404, profile: scanmix}\n    - {seed: 1505, profile: multi_cf}\n    - {seed: 1606, profile: time_series}\n    - {seed: 1707, profile: difficulty}\n    - {seed: 1808, profile: overlap_rewrite}\n  build_timeout_seconds: 7200\n  run_timeout_seconds: 1800\n  build_jobs: 3\nsubmission:\n  kind: file\n  path: /app/solution.patch\n  allow_empty: true\n  max_queue_size: 2\n"}