Dataset Viewer
Auto-converted to Parquet Duplicate
suite_version
stringclasses
1 value
pool_sha256
stringclasses
1 value
source_commit
stringclasses
1 value
task_id
stringlengths
9
20
family_id
stringclasses
6 values
input_type
stringclasses
3 values
hypothesis_class
stringclasses
6 values
target_candidate_index
int64
0
5
reference_function_js
stringlengths
36
106
shown_examples
listlengths
16
16
held_out_examples
listlengths
50
50
2.1.0
aaa29189f284bb9624a5fc45649c13ac8e8adc625540614c9e93744324508ae6
6b1a6be1975561240edfd4dffab77236b036798e
threshold-1
threshold
integer
f(n) is n*n for n <= t, and n*n-c otherwise. t is one of -3, 0, 3; c is one of 7, 11.
1
const f = n => n <= -3 ? n*n : n*n-11;
[ { "index": 0, "input_json": "-42", "output_json": "1764" }, { "index": 1, "input_json": "-100", "output_json": "10000" }, { "index": 2, "input_json": "-114", "output_json": "12996" }, { "index": 3, "input_json": "-30", "output_json": "900" }, { "in...
[ { "index": 0, "input_json": "-1", "output_json": "-10" }, { "index": 1, "input_json": "65", "output_json": "4214" }, { "index": 2, "input_json": "101", "output_json": "10190" }, { "index": 3, "input_json": "119", "output_json": "14150" }, { "index"...
2.1.0
aaa29189f284bb9624a5fc45649c13ac8e8adc625540614c9e93744324508ae6
6b1a6be1975561240edfd4dffab77236b036798e
threshold-2
threshold
integer
f(n) is n*n for n <= t, and n*n-c otherwise. t is one of -3, 0, 3; c is one of 7, 11.
5
const f = n => n <= 3 ? n*n : n*n-11;
[ { "index": 0, "input_json": "94", "output_json": "8825" }, { "index": 1, "input_json": "-2", "output_json": "4" }, { "index": 2, "input_json": "74", "output_json": "5465" }, { "index": 3, "input_json": "117", "output_json": "13678" }, { "index": 4,...
[ { "index": 0, "input_json": "2", "output_json": "4" }, { "index": 1, "input_json": "72", "output_json": "5173" }, { "index": 2, "input_json": "-25", "output_json": "625" }, { "index": 3, "input_json": "-59", "output_json": "3481" }, { "index": 4, ...
2.1.0
aaa29189f284bb9624a5fc45649c13ac8e8adc625540614c9e93744324508ae6
6b1a6be1975561240edfd4dffab77236b036798e
modular-1
modular
integer
f(n) is n+b when n is divisible by d, and n-b otherwise. d is one of 2, 3, 4; b is one of 1, 3.
0
const f = n => n % 2 === 0 ? n+1 : n-1;
[ { "index": 0, "input_json": "-57", "output_json": "-58" }, { "index": 1, "input_json": "65", "output_json": "64" }, { "index": 2, "input_json": "119", "output_json": "118" }, { "index": 3, "input_json": "51", "output_json": "50" }, { "index": 4, ...
[ { "index": 0, "input_json": "-106", "output_json": "-105" }, { "index": 1, "input_json": "-32", "output_json": "-31" }, { "index": 2, "input_json": "95", "output_json": "94" }, { "index": 3, "input_json": "66", "output_json": "67" }, { "index": 4, ...
2.1.0
aaa29189f284bb9624a5fc45649c13ac8e8adc625540614c9e93744324508ae6
6b1a6be1975561240edfd4dffab77236b036798e
modular-2
modular
integer
f(n) is n+b when n is divisible by d, and n-b otherwise. d is one of 2, 3, 4; b is one of 1, 3.
3
const f = n => n % 3 === 0 ? n+3 : n-3;
[ { "index": 0, "input_json": "102", "output_json": "105" }, { "index": 1, "input_json": "77", "output_json": "74" }, { "index": 2, "input_json": "-95", "output_json": "-98" }, { "index": 3, "input_json": "-109", "output_json": "-112" }, { "index": 4...
[ { "index": 0, "input_json": "44", "output_json": "41" }, { "index": 1, "input_json": "56", "output_json": "53" }, { "index": 2, "input_json": "-40", "output_json": "-43" }, { "index": 3, "input_json": "64", "output_json": "61" }, { "index": 4, ...
2.1.0
aaa29189f284bb9624a5fc45649c13ac8e8adc625540614c9e93744324508ae6
6b1a6be1975561240edfd4dffab77236b036798e
conditional-string-1
conditional-string
string
If the first character (case insensitive) is in a selected group, transform the string; otherwise return it unchanged. The group is one of aeiou, abc, xyz. The transform either uppercases the first character or reverses the entire string. Empty strings are unchanged.
1
const f = s => s.length && "aeiou".includes(s[0].toLowerCase()) ? [...s].reverse().join("") : s;
[ { "index": 0, "input_json": "\"xelszgnubipw\"", "output_json": "\"xelszgnubipw\"" }, { "index": 1, "input_json": "\"cj\"", "output_json": "\"cj\"" }, { "index": 2, "input_json": "\"vcjqxelszgn\"", "output_json": "\"vcjqxelszgn\"" }, { "index": 3, "input_json":...
[ { "index": 0, "input_json": "\"elszgnubipwd\"", "output_json": "\"dwpibungzsle\"" }, { "index": 1, "input_json": "\"ub\"", "output_json": "\"bu\"" }, { "index": 2, "input_json": "\"x\"", "output_json": "\"x\"" }, { "index": 3, "input_json": "\"ry\"", "outp...
2.1.0
aaa29189f284bb9624a5fc45649c13ac8e8adc625540614c9e93744324508ae6
6b1a6be1975561240edfd4dffab77236b036798e
conditional-string-2
conditional-string
string
If the first character (case insensitive) is in a selected group, transform the string; otherwise return it unchanged. The group is one of aeiou, abc, xyz. The transform either uppercases the first character or reverses the entire string. Empty strings are unchanged.
5
const f = s => s.length && "xyz".includes(s[0].toLowerCase()) ? [...s].reverse().join("") : s;
[ { "index": 0, "input_json": "\"bipwdkry\"", "output_json": "\"bipwdkry\"" }, { "index": 1, "input_json": "\"x\"", "output_json": "\"x\"" }, { "index": 2, "input_json": "\"m\"", "output_json": "\"m\"" }, { "index": 3, "input_json": "\"gnubipwd\"", "output_j...
[ { "index": 0, "input_json": "\"zgnubip\"", "output_json": "\"pibungz\"" }, { "index": 1, "input_json": "\"ipwdkr\"", "output_json": "\"ipwdkr\"" }, { "index": 2, "input_json": "\"zg\"", "output_json": "\"gz\"" }, { "index": 3, "input_json": "\"fmtahov\"", ...
2.1.0
aaa29189f284bb9624a5fc45649c13ac8e8adc625540614c9e93744324508ae6
6b1a6be1975561240edfd4dffab77236b036798e
rotation-1
rotation
string
Rotate the string cyclically by k positions, either left or right. k is one of 1, 2, 3. Reduce k modulo string length; empty strings are unchanged.
2
const f = s => { if (!s.length) return s; const k=2%s.length; return s.slice(k)+s.slice(0,k); };
[ { "index": 0, "input_json": "\"w\"", "output_json": "\"w\"" }, { "index": 1, "input_json": "\"o\"", "output_json": "\"o\"" }, { "index": 2, "input_json": "\"c\"", "output_json": "\"c\"" }, { "index": 3, "input_json": "\"g\"", "output_json": "\"g\"" }, ...
[ { "index": 0, "input_json": "\"tahovcjqx\"", "output_json": "\"hovcjqxta\"" }, { "index": 1, "input_json": "\"elszgnubip\"", "output_json": "\"szgnubipel\"" }, { "index": 2, "input_json": "\"fmt\"", "output_json": "\"tfm\"" }, { "index": 3, "input_json": "\"bi...
2.1.0
aaa29189f284bb9624a5fc45649c13ac8e8adc625540614c9e93744324508ae6
6b1a6be1975561240edfd4dffab77236b036798e
rotation-2
rotation
string
Rotate the string cyclically by k positions, either left or right. k is one of 1, 2, 3. Reduce k modulo string length; empty strings are unchanged.
1
const f = s => { if (!s.length) return s; const k=1%s.length; return k ? s.slice(-k)+s.slice(0,-k) : s; };
[ { "index": 0, "input_json": "\"xel\"", "output_json": "\"lxe\"" }, { "index": 1, "input_json": "\"dkr\"", "output_json": "\"rdk\"" }, { "index": 2, "input_json": "\"b\"", "output_json": "\"b\"" }, { "index": 3, "input_json": "\"q\"", "output_json": "\"q\""...
[ { "index": 0, "input_json": "\"pwdkryfm\"", "output_json": "\"mpwdkryf\"" }, { "index": 1, "input_json": "\"wd\"", "output_json": "\"dw\"" }, { "index": 2, "input_json": "\"ahovcjqxel\"", "output_json": "\"lahovcjqxe\"" }, { "index": 3, "input_json": "\"xelszg...
2.1.0
aaa29189f284bb9624a5fc45649c13ac8e8adc625540614c9e93744324508ae6
6b1a6be1975561240edfd4dffab77236b036798e
distinct-rank-1
distinct-rank
array of integers
Return the kth distinct value in ascending or descending order. k is one of 1, 2, 3. Return null if fewer than k distinct values exist.
3
const f = a => { const d=[...new Set(a)].sort((x,y)=>-1*(x-y)); return d.length < 2 ? null : d[1]; };
[ { "index": 0, "input_json": "[7]", "output_json": "null" }, { "index": 1, "input_json": "[6]", "output_json": "null" }, { "index": 2, "input_json": "[11]", "output_json": "null" }, { "index": 3, "input_json": "[-12,-12]", "output_json": "null" }, { ...
[ { "index": 0, "input_json": "[-9,-8,-1,10,11,5]", "output_json": "10" }, { "index": 1, "input_json": "[-14,11,4,9,-5]", "output_json": "9" }, { "index": 2, "input_json": "[9,12,1,7,1]", "output_json": "9" }, { "index": 3, "input_json": "[6,10,-5,-8,-13,-2]", ...
2.1.0
aaa29189f284bb9624a5fc45649c13ac8e8adc625540614c9e93744324508ae6
6b1a6be1975561240edfd4dffab77236b036798e
distinct-rank-2
distinct-rank
array of integers
Return the kth distinct value in ascending or descending order. k is one of 1, 2, 3. Return null if fewer than k distinct values exist.
0
const f = a => { const d=[...new Set(a)].sort((x,y)=>1*(x-y)); return d.length < 1 ? null : d[0]; };
[ { "index": 0, "input_json": "[-6,5]", "output_json": "-6" }, { "index": 1, "input_json": "[1,-1]", "output_json": "-1" }, { "index": 2, "input_json": "[10,-2]", "output_json": "-2" }, { "index": 3, "input_json": "[-9,1]", "output_json": "-9" }, { "...
[ { "index": 0, "input_json": "[15,-15,10,11,4,-12,2,-5]", "output_json": "-15" }, { "index": 1, "input_json": "[0,-2,-11,-3]", "output_json": "-11" }, { "index": 2, "input_json": "[-4,8,-5,-6,9,15,3]", "output_json": "-6" }, { "index": 3, "input_json": "[13,-10...
2.1.0
aaa29189f284bb9624a5fc45649c13ac8e8adc625540614c9e93744324508ae6
6b1a6be1975561240edfd4dffab77236b036798e
filter-order-1
filter-order
array of integers
Keep only values divisible by d, preserving duplicates. d is one of 2, 3, 4. Return them either in their original order or sorted numerically ascending.
3
const f = a => a.filter(x=>x%3===0).sort((x,y)=>x-y);
[ { "index": 0, "input_json": "[-4,4,10,-6,-10,13,6]", "output_json": "[-6,6]" }, { "index": 1, "input_json": "[5,-14,-9,0,-14,-11]", "output_json": "[-9,0]" }, { "index": 2, "input_json": "[5,11,5,-13,-15]", "output_json": "[-15]" }, { "index": 3, "input_json":...
[ { "index": 0, "input_json": "[0,-9]", "output_json": "[-9,0]" }, { "index": 1, "input_json": "[-11,13,9,-4,8,-14]", "output_json": "[9]" }, { "index": 2, "input_json": "[-6,-6,15,2,-15,-4,0,-12]", "output_json": "[-15,-12,-6,-6,0,15]" }, { "index": 3, "input_j...
2.1.0
aaa29189f284bb9624a5fc45649c13ac8e8adc625540614c9e93744324508ae6
6b1a6be1975561240edfd4dffab77236b036798e
filter-order-2
filter-order
array of integers
Keep only values divisible by d, preserving duplicates. d is one of 2, 3, 4. Return them either in their original order or sorted numerically ascending.
0
const f = a => a.filter(x=>x%2===0);
[ { "index": 0, "input_json": "[3,-8,-13,9,9,15]", "output_json": "[-8]" }, { "index": 1, "input_json": "[-4,0,-9,8]", "output_json": "[-4,0,8]" }, { "index": 2, "input_json": "[11,0,5,-15,11]", "output_json": "[0]" }, { "index": 3, "input_json": "[-1]", "ou...
[ { "index": 0, "input_json": "[6,9,-12,15]", "output_json": "[6,-12]" }, { "index": 1, "input_json": "[1,8,-10]", "output_json": "[8,-10]" }, { "index": 2, "input_json": "[-6,-8,-14]", "output_json": "[-6,-8,-14]" }, { "index": 3, "input_json": "[12,-4,-7]", ...

Monkey See / Monkey Do — suite 2.1.0

A deterministic, synthetic evaluation dataset for two narrow tasks: Monkey See (SEE) measures identification of a rule from examples within a specified finite hypothesis class. Monkey Do (DO) measures the quality of JavaScript solver programs for string-rewrite systems.

This package contains the frozen suite 2.1.0 task sets, exact prompts, rule definitions, reference programs and answers, and provenance. Intended Hub repository: noahmclaughlin/monkey-see-monkey-do. Noah McLaughlin is the repository's named copyright holder; the dataset publisher is noahmclaughlin.

This is evaluation material, including public answer keys. The test designation identifies the evaluation split; it does not mean the contents are secret or uncontaminated. There is no training or validation split. Training on this package invalidates claims that a subsequent score measures unseen-task performance.

Contents and loading

Configuration Test rows Unit
see_tasks 12 One rule instance; 16 shown and 50 held-out examples with reference answers
see_prompts 48 One instance at one sample level (2, 4, 8 or 16)
do_chains 60 One start/target pair with a reference derivation
do_systems 3 One rule system, exact solver prompt and reference solver

SEE has six families, each with two instances: threshold arithmetic, modular arithmetic, conditional string transforms, rotations, distinct order statistics, and array filtering with ordering. Across instances there are 192 shown examples and 600 held-out examples. DO has growth, reversible swaps and reductions, with four chains per system at each shortest-distance band 5, 10, 20, 30 and 50. Rows across configurations are related records, not independent observations.

After publication:

import json
from datasets import load_dataset

repo = "noahmclaughlin/monkey-see-monkey-do"
tasks = load_dataset(repo, "see_tasks", split="test")
prompts = load_dataset(repo, "see_prompts", split="test")
chains = load_dataset(repo, "do_chains", split="test")
systems = load_dataset(repo, "do_systems", split="test")

example = tasks[0]["held_out_examples"][0]
input_value = json.loads(example["input_json"])
reference_answer = json.loads(example["output_json"])

For a local download, replace repo with the package directory. To reproduce a published experiment, also pin revision to its Hub commit and record the source suite and pool hashes. Loading this dataset does not execute its JavaScript. The Python datasets library is optional; JSONL files can be read directly.

Schema

All four configurations carry suite_version, pool_sha256 and source_commit.

SEE tasks: task_id, family_id, input_type, hypothesis_class, target_candidate_index (zero-based index into rules.json), reference_function_js, shown_examples and held_out_examples. Each example has a zero-based index, input_json and output_json. Mixed integers, strings, arrays and null answers are encoded as JSON strings to keep a stable Arrow schema. Decode them with json.loads; the string "null" represents a null answer, not a missing label. Shown example order is significant.

SEE prompts: task_id, family_id, sample_level, contributes_to_headline, prompt, prompt_sha256 and compatible_candidate_count. Use the exact prompt field as model input. Do not include the task's selected candidate, reference code or held-out answers.

DO chains: chain_id, system_id, shortest_distance, band, start, target and reference_steps. Each step has rule (rule ID), start (zero-based substring position), and next (the complete resulting string). A step's start is an integer position, distinct from the chain's start string.

DO systems: system_id, rules, prompt, prompt_sha256, reference_solver_js and chain_count. Each rule has id, from and to. Only one matching substring is rewritten per move; other characters are inert. Rule IDs are scoped to the system. Join chains to systems by system_id.

rules.json includes all six SEE candidate classes, all candidate JavaScript functions, naive baselines, and all DO rule definitions. Reference functions and solvers are executable JavaScript source strings; they are not model responses. source/pool.json and source/prompt-digests.json preserve the exact source files.

Evaluation protocol and scoring

A full repeat makes 51 model calls: 48 SEE calls and three DO calls. For DO, the model receives one general solver prompt per system, returns a solve(start, target) program, and the harness executes it on that system's 20 chains. Supplying individual chain pairs to the model would be a different task.

SEE's headline is 50 × mean held-out accuracy at level 16, equally weighted across the 12 instances. Earlier levels are diagnostics only. Their examples preserve multiple plausible candidates through level 8; level 16 identifies a unique candidate within the declared class. Held-out witnesses independently separate the target from every incorrect declared candidate. Inputs are unique and shown/held-out sets are disjoint within each instance; no disjointness between different instances or families is promised.

DO's headline is 50 × mean solved fraction, balanced across systems and bands. Full credit requires all moves to be legal and the final string to equal the target. Any valid complete derivation is accepted, including a different or longer path than the stored reference. Legal prefixes earn zero. Limits: 1000 moves, intermediate strings of at most 128 characters, and 3000 ms execution per chain. SEE uses 1000 ms per input. Each invocation gets a fresh JavaScript context. The reference search's 100000-state stopping threshold is a reference algorithm choice, not an extra restriction on model programs.

There is no adjusted or combined headline score. Non-throwing rate and the shown-minus-held-out gap are diagnostics. Unusable programs retain their case denominators. API failures are missing measurements, not model zeros. Record provider, reasoning effort, sampling settings, effective API/output budgets and runtime alongside any results. Pin routed providers when measuring a hosted model.

Use the source scoring specification and harness for comparable measurements; this dataset is not a replacement scorer. No empirical model-performance results or downstream validity claims are included.

Generation, references and provenance

Data were generated programmatically, without human annotators or model-generated labels, from seed 0xC0FFEE (12648430), generator version 2.1.0. SEE selects two candidate rules per family, reserves held-out discriminating witnesses, and constructs controlled ambiguous prefixes. Its reference answers are computed from the selected functions. DO chains are constructed for the five bands, independently solved with bidirectional BFS, and replay-verified.

The pool hash is over the canonical JSON body without its sha256 member; it is not the SHA-256 of the formatted pool file. The manifest separately hashes file bytes. The package does not include credentials, user records or model-run reports.

Verify the downloaded package offline with Node 20 or newer:

node verify.mjs

This checks file checksums, all 792 SEE reference outputs, exact prompt hashes, all 60 recorded paths, and all 60 independently searched DO solutions. The repository exporter also runs the full self-test and deterministic regeneration. A checksum establishes consistency, not authenticity; compare provenance against the pinned source commit when auditing origin. For source-level reproduction:

git clone https://github.com/1999labs/monkey-see-monkey-do.git
cd monkey-see-monkey-do
git checkout 6b1a6be1975561240edfd4dffab77236b036798e
npm test
npm run self-test
npm run check-pool
npm run dry-run

The packaging exporter is maintained separately as scripts/export-hf.mjs in the source repository; its digest is recorded in provenance. It does not modify suite inputs, rule definitions, prompts or score calculations.

Intended use and limitations

Suitable uses include reproducible solver-program evaluation, debugging narrow failure modes, and studying behavior under controlled changes in available examples.

  • Six finite rule classes and three rewrite systems provide narrow coverage. Unique identification holds only within the declared candidate class.
  • Early examples are deliberately ambiguous. The information transition is constructed; the curve is not a natural random-example sample-efficiency estimate.
  • DO scores a generated program, not the model executing a chain of thought. Length, branching, search strategy and resource budget are confounded.
  • Public data and textbook algorithms may be recalled. Prompt/version hashes do not detect prior exposure. Avoid training on the answers before evaluating.
  • Within-family instances and chains answered by one solver are correlated. Counts of cases are not counts of independent model decisions.
  • There is no demonstrated relationship to agentic software-engineering success. This suite does not edit repositories or use tools on the evaluated model's behalf. Do not compare its scores directly with external benchmark leaderboards.
  • The harness's node:vm timeouts do not provide a security boundary or memory cap.
  • 2.1.0 is incompatible with earlier SEE scores; pool changes also affect DO pairs. Compare only measurements with matching suite, prompt and pool identifiers.

The synthetic domains and designed rule choices encode researcher preferences; expanding their count does not establish population representativeness. There are no personal-data subjects in these generated task sets. No empirical fairness assessment or broad capability validation is claimed.

License and attribution

MIT; see LICENSE. Copyright (c) 2026 Noah McLaughlin. When citing an evaluation, include the dataset ID, suite 2.1.0, source commit, pool digest and the Hub revision used. This package has no associated paper or DOI.

Downloads last month
50