datasets
Collection
Reasoning Core ◉
Pre-generated symbolic reasoning data, from pre-training pile to post-training environments • 7 items • Updated • 4
Datasets:
task large_string | prompt large_string | answer large_string | metadata large_string | cot large_string | level int64 | mode large_string |
|---|---|---|---|---|---|---|
combinatorics_formula_selection | Which expression counts the outcomes? Answer A-D.
C(n,k): unordered; P(n,k): ordered.
Problem:
Walk east or north from (0,0) to (7,8), stopping at (3,5) on the way. Count the routes.
Options:
A. C(8,3)*C(6,4)
B. C(8,3)*C(7,4)
C. C(15,7)
D. C(7,3)*C(7,4) | B | {"family": "path_through_point", "structural_depth": 2, "program_type": "ThroughPointPath", "program": {"right": 7, "up": 8, "point_right": 3, "point_up": 5}, "correct_expression": "C(8,3)*C(7,4)", "correct_option_index": 1, "correct_features": {"top_operator": "product", "ast_size": 7, "contains_combination": true, "c... | null | 0 | instruct |
code_execution | Predict the value returned by this Python call.
```python
def f0(j: int, n: int) -> int:
j = 4
j = 6 + 4
while n > -3:
print(j)
n = n - 2
return n + j
def f1(d: str) -> int:
a = [y % 4 for y in range(5, 10)]
return 0
def f2(b: int) -> list:
b = (b if b != b else 0) - 1
b ... | 7 | {"code": "def f0(j: int, n: int) -> int:\n j = 4\n j = 6 + 4\n while n > -3:\n print(j)\n n = n - 2\n return n + j\ndef f1(d: str) -> int:\n a = [y % 4 for y in range(5, 10)]\n return 0\ndef f2(b: int) -> list:\n b = (b if b != b else 0) - 1\n b = f\"val={b}\" + f\"x={b}\"\n ret... | null | 2 | instruct |
metamath_entailment | Does the conjecture follow using only the listed premises and rules?
Rules instantiate only by renaming variables.
The answer is True or False.
Premises:
1. ctx => P2(x, D1)
2. P3(y, x)
3. ctx => P3(y, z)
4. P3(u, z)
5. ctx => P3(x, z)
Allowed Rules:
r1: P3(u, z); ctx => P3(u, y); ctx => P3(z, x) ==> ctx => P3(y, x)
... | False | {"premises": ["ctx => P2(x, D1)", "P3(y, x)", "ctx => P3(y, z)", "P3(u, z)", "ctx => P3(x, z)"], "raw_premises": [["|-", "(", "ph", "->", "D", "e.", "RR", ")"], ["|-", "C", "=", "D"], ["|-", "(", "ph", "->", "C", "=", "B", ")"], ["|-", "A", "=", "B"], ["|-", "(", "ph", "->", "D", "=", "B", ")"]], "rules": ["r1", "r2", ... | null | 0 | instruct |
analogical_case_matching | Which case matches Query under consistent entity/relation renaming and per-relation direction reversal? Answer with its ID, or None.
M0: a alpha c, a alpha f, d beta c, b gamma f, e gamma f
M1: c alpha b, f beta a, f beta b, f beta d, f gamma d
M2: e alpha a, e alpha c, f alpha d, a beta c, f gamma b
M3: f alpha c, d ... | M0 | {"cases": [{"id": "M0", "context": [["alpha", "a", "c"], ["alpha", "a", "f"], ["beta", "d", "c"], ["gamma", "b", "f"], ["gamma", "e", "f"]], "consequence": ["gamma", "a", "d"]}, {"id": "M1", "context": [["alpha", "c", "b"], ["beta", "f", "a"], ["beta", "f", "b"], ["beta", "f", "d"], ["gamma", "f", "d"]], "consequence":... | null | 2 | instruct |
rewrite_system | Normalize by the ordered rewrite rules. At each step, scan subterm positions outermost-first and left-to-right. Stop at the first position matched by at least one rule, then apply the earliest matching rule in the listed order (position priority first; rule priority second).
Rules:
- const(X,Y) -> X
- fst(pair(X,Y)) -... | No | {"theory": "ast", "rules": "- const(X,Y) -> X\n- fst(pair(X,Y)) -> X\n- snd(pair(X,Y)) -> Y\n- if(true,X,Y) -> X\n- let(unit,X) -> X\n- if(false,X,Y) -> Y\n- id(X) -> X", "term": "if(id(id(id(false))),true,true)", "normal_form": "true", "used": ["id", "id", "id", "if_false"], "cot": "-> if(id(id(false)),true,true)\n-> ... | null | 1 | verification |
multistep_nli | Premise:
clara is a parent of bruno.
bruno is a parent of elena.
elena is a parent of farah.
alice is not patient.
bruno is careful.
bruno is kind.
For all x, y, if x is a parent of y, then x is an ancestor of y.
For all x, y, z, if x is a parent of y and y is an ancestor of z, then x is an ancestor of z.
From p is a p... | Yes | {"premise": ["clara is a parent of bruno.", "bruno is a parent of elena.", "elena is a parent of farah.", "alice is not patient.", "bruno is careful.", "bruno is kind.", "For all x, y, if x is a parent of y, then x is an ancestor of y.", "For all x, y, z, if x is a parent of y and y is an ancestor of z, then x is an an... | null | 2 | instruct |
table_qa | Execute this SQL query on the table named dataframe:
Table 1:
{"date": "25 janv. 2025", "qty": "2", "row_id": "R0000", "unit_price": "39.62", "country": "Germany", "status": "paid", "category": "Clothing"}
{"date": "4 mai 2026", "qty": "5", "row_id": "R0001", "unit_price": "53.63", "country": "France", "status": "paid... | Electronics | {"table": "{\"date\": \"25 janv. 2025\", \"qty\": \"2\", \"row_id\": \"R0000\", \"unit_price\": \"39.62\", \"country\": \"Germany\", \"status\": \"paid\", \"category\": \"Clothing\"}\n{\"date\": \"4 mai 2026\", \"qty\": \"5\", \"row_id\": \"R0001\", \"unit_price\": \"53.63\", \"country\": \"France\", \"status\": \"paid... | null | 2 | instruct |
parsing_derivation | (START)
start
(GRAMMAR)
R0: seq -> expr seq
R1: expr -> '<' seq '>'
R2: start -> seq
R3: seq ->
R4: expr -> '(' seq ')'
R5: expr -> '[' seq ']'
(STRING)
( ) ( )
(QUESTION)
The answer is the rule labels used in the leftmost derivation of STRING, in order, separated by spaces. | R2 R0 R4 R3 R0 R4 R3 R3 | {"label": "unambiguous", "tokens": ["(", ")", "(", ")"], "g": "seq -> \nexpr -> '(' seq ')'\nseq -> expr seq\nstart -> seq\nexpr -> '[' seq ']'\nexpr -> '<' seq '>'", "start": "start", "labeled_g": "R0: seq -> expr seq\nR1: expr -> '<' seq '>'\nR2: start -> seq\nR3: seq -> \nR4: expr -> '(' seq ')'\nR5: expr -> '[' seq... | null | 0 | instruct |
table_equivalence | Do these tables contain the same data?
Ignore row order, column order, and table syntax; match values by column name.
Treat numeric grouping and trailing zeros as formatting, ISO and English month-name dates as dates, and — and NULL as missing. Repeated rows count.
Table A:
event_date,amount,qty
2025-07-23,576.73,394
... | Yes | {"table_a": "event_date,amount,qty\n2025-07-23,576.73,394\n\u2014,427.63,717\n2024-11-13,1586.21,597\n2025-03-28,593.88,949\n", "table_b": "amount|qty|event_date\n593.88|949.00|Mar 28, 2025\n1,586.21|597.00|Nov 13, 2024\n576.73|394.00|Jul 23, 2025\n427.63|717.00|NULL\n", "format_a": "to_csv", "format_b": "to_pipe", "mu... | null | 0 | instruct |
qualitative_causal_reasoning | Assume linear causal relations, independent noise, and no exact cancellations.
X10 directly decreases X2; X12 directly decreases X8; X13 directly decreases X1; X3 directly decreases X11; X4 directly increases X9; X5 directly increases X6; X5 directly increases X7; X6 directly increases X1; X6 directly decreases X12.
... | no_effect | {"edges": [["X10", "X2", "-"], ["X12", "X8", "-"], ["X13", "X1", "-"], ["X3", "X11", "-"], ["X4", "X9", "+"], ["X5", "X6", "+"], ["X5", "X7", "+"], ["X6", "X1", "+"], ["X6", "X12", "-"]], "nodes": ["X0", "X1", "X10", "X11", "X12", "X13", "X2", "X3", "X4", "X5", "X6", "X7", "X8", "X9"], "query": {"kind": "intervention",... | null | 1 | instruct |
regex_following | The answer is the shortest non-empty visible non-whitespace ASCII string that fully matches this regular expression, with lexicographic tie-breaks: \].*? | ] | {"regex": "\\].*?", "string": "]", "_time": 0.005178213119506836, "_task": "regex_following", "_level": 2, "_config": {"level": 2, "seed": null, "size": null, "n_ex": 10, "max_depth": 7, "min_depth": 5, "n_alpha": 4, "max_answer_len": 24, "max_synth_nodes": 200000, "require_unique": true}, "_prompt_tokens": 32, "_answe... | null | 2 | instruct |
unification_entailment | Compute a most general unifier of the equations. Apply it to both sides of the candidate equality. Answer Yes if the instantiated candidate terms are identical, otherwise answer No. The equations are guaranteed to be unifiable.
Equations:
- p(x1, c) = p(x1, x0)
Candidate:
c = x0 | Yes | {"answer": "Yes", "equations": ["p(x1, c) = p(x1, x0)"], "candidate": "c = x0", "num_equations": 1, "num_variables": 2, "num_bindings_in_mgu": 1, "max_term_depth": 1, "candidate_depth": 0, "trace_steps": 2, "num_decompositions": 1, "num_alias_bindings": 0, "num_sharing_constraints": 0, "num_redundant_equations": 0, "di... | null | 0 | instruct |
grid_navigation | Grid [0,4]x[0,4], N=+y, E=+x.
Initial Facts:
- B is above C.
- B is right of C.
- B starts at (4, 3).
- A is above C.
- A is below B.
- B is right of A.
- A starts at (0, 2).
- C is right of A.
Steps:
1. B and C swap positions.
What is the final Manhattan distance between A and C? The answer is an integer. | 5 | {"answer_type": "distance", "query_a": "A", "query_b": "C", "grid": 4, "objects": ["A", "B", "C"], "facts": [{"k": "v", "a": "B", "b": "C", "r": "above"}, {"k": "h", "a": "B", "b": "C", "r": "right"}, {"k": "coord", "a": "B", "p": [4, 3]}, {"k": "v", "a": "A", "b": "C", "r": "above"}, {"k": "v", "a": "A", "b": "B", "r"... | null | 0 | instruct |
graph_successors | For each query (x, k), give the k-th successor of x by following directed edges k times.
Answer with space-separated integers in query order.
Graph:
Adjacency Dictionary (source to targets): {0: [1], 1: [0], 2: [4], 3: [3], 4: [5], 5: [2]}
Queries:
[(4, 1)] | 5 | {"graph_description": "Adjacency Dictionary (source to targets): {0: [1], 1: [0], 2: [4], 3: [3], 4: [5], 5: [2]}", "queries": [[4, 1]], "payload": {"graph": "Adjacency Dictionary (source to targets): {0: [1], 1: [0], 2: [4], 3: [3], 4: [5], 5: [2]}", "queries": "[(4, 1)]"}, "nodes": [0, 1, 2, 3, 4, 5], "edges": [[0, 1... | null | 0 | instruct |
game_best_move | In this graph game, choose player's best move. Player chooses on player turns; opponent chooses on opponent turns. Opponent minimizes player score.
Start: n3. Turns alternate player, opponent. Move along one edge per turn, for at most 3 moves. Play ends upon reaching a leaf or the move horizon; in either case, player'... | n4 | {"rules": "role(player).\nrole(opponent).\ninit(at(n3)).\ninit(step(t0)).\ninit(control(player)).\nsucc(t0,t1). succ(t1,t2). succ(t2,t3).\nedge(n0,n4). edge(n1,n3). edge(n1,n4). edge(n1,n8). edge(n2,n6). edge(n2,n8). edge(n3,n4). edge(n3,n6). edge(n4,n7). edge(n5,n6). edge(n5,n7). edge(n5,n8).\nleaf(n6). leaf(n7). leaf... | null | 2 | instruct |
most_probable_evidence | Factor c is independently true with probability 0.4.
Factor f is independently true with probability 0.7.
Factor e is independently true with probability 0.7.
The observation holds exactly when ((factor c or factor f) holds and factor e is false).
We observe it.
Which hidden fact values form the most probable complete ... | 1 3 4 | {"problog": "0.4::c.\n0.7::f.\n0.7::e.\nobserved :- ((c;f),\\+e).\nevidence(observed,true).", "english": "Factor c is independently true with probability 0.4.\nFactor f is independently true with probability 0.7.\nFactor e is independently true with probability 0.7.\nThe observation holds exactly when ((factor c or fac... | null | 1 | instruct |
lambda_reduction | Reduce the following untyped λ-term to β-normal form.
Syntax: `\x.body` is λx.body; juxtaposition is left-associative application; free identifiers are constants.
Term: ((d (\v0.((((\_1.d) (b c)) ((v0 ((\_3.(d ((\_6._6) (((\_5._5) ((((\_8.(\_7._8)) v0) a) v0)) _3)))) (v0 ((\_0._0) (v0 ((\_4.v0) c)))))) ((\_2.v0) d))) ... | Yes | {"term": "((d (\\v0.((((\\_1.d) (b c)) ((v0 ((\\_3.(d ((\\_6._6) (((\\_5._5) ((((\\_8.(\\_7._8)) v0) a) v0)) _3)))) (v0 ((\\_0._0) (v0 ((\\_4.v0) c)))))) ((\\_2.v0) d))) v0))) a)", "normal_form": "((d (\\x0.((d ((x0 (d ((x0 x0) (x0 (x0 x0))))) x0)) x0))) a)", "beta_steps": 9, "has_shadowing": false, "shadowing": 0, "ca... | null | 3 | verification |
set_missing_element | Answer with the missing elements in the ordered span of [198, 190, 187, 193, 197, 182, 199, 194, 180, 186, 183, 188, 192, 191, 185, 181, 196] as a Python set. | {184, 189, 195} | {"element_list": [198, 190, 187, 193, 197, 182, 199, 194, 180, 186, 183, 188, 192, 191, 185, 181, 196], "missing_count": 3, "_time": 0.0004031658172607422, "_task": "set_missing_element", "_level": 3, "_config": {"level": 3, "seed": null, "size": null, "domain_size": 675, "set_size": 20, "n_domains": 5, "prob_no_missin... | null | 3 | instruct |
defeasible_nli | An `unless` condition must be shown to block its rule.
Facts:
Elena is alpha-tagged and foxtrot-tagged.
David is alpha-tagged, bravo-tagged, foxtrot-tagged, gamma-tagged, and lambda-tagged.
Alice is delta-tagged and bravo-tagged.
Clara is echo-tagged.
Bruno is gamma-tagged.
Elena is alpha-linked to David.
Rules:
Alph... | No | {"premise": ["Elena is alpha tagged.", "David is alpha tagged.", "David is bravo tagged.", "Elena is foxtrot tagged.", "David is foxtrot tagged.", "David is gamma tagged.", "Elena is alpha-linked to David.", "David is lambda tagged.", "Alice is delta tagged.", "Clara is echo tagged.", "Bruno is gamma tagged.", "Alice i... | null | 1 | instruct |
game_forced_win | In this graph game, decide whether player can force a win. Player chooses on player turns; opponent chooses on opponent turns. Opponent minimizes player score. A win means final player score is greater than 50.
Start: n1. Turns alternate player, opponent. Move along one edge per turn, for at most 3 moves. Play ends up... | Yes | {"rules": "role(player).\nrole(opponent).\ninit(at(n1)).\ninit(step(t0)).\ninit(control(player)).\nsucc(t0,t1). succ(t1,t2). succ(t2,t3).\nedge(n0,n2). edge(n0,n3). edge(n1,n2). edge(n1,n4). edge(n2,n3). edge(n3,n5). edge(n3,n6).\nleaf(n4). leaf(n5). leaf(n6).\nvalue(n0,40). value(n1,0). value(n2,40). value(n3,40). val... | null | 0 | verification |
graph_successors | For each query (x, k), give the k-th successor of x by following directed edges k times.
Answer with space-separated integers in query order.
Graph:
Adjacency Dictionary (source to targets): {0: [7], 1: [2], 2: [3], 3: [1], 4: [6], 5: [0], 6: [5], 7: [4]}
Queries:
[(4, 4), (1, 1)] | 7 2 | {"graph_description": "Adjacency Dictionary (source to targets): {0: [7], 1: [2], 2: [3], 3: [1], 4: [6], 5: [0], 6: [5], 7: [4]}", "queries": [[4, 4], [1, 1]], "payload": {"graph": "Adjacency Dictionary (source to targets): {0: [7], 1: [2], 2: [3], 3: [1], 4: [6], 5: [0], 6: [5], 7: [4]}", "queries": "[(4, 4), (1, 1)]... | null | 2 | instruct |
math_word_problem | Hana has 3 times as many tiles as Zara. Nina has 2 times as many tiles as Hana. Carlos has half as many tiles as Hana. Mei has half as many tiles as Zara. Diego has a quarter as many tiles as Mei. Mei has 24 tiles. How many tiles does Diego have? Answer with a number. | 6 | {"family": "relational", "unit": "tiles", "names": ["Zara", "Hana", "Carlos", "Mei", "Nina", "Diego"], "relations": [["times", "Hana", "Zara", 3, null], ["times", "Nina", "Hana", 2, null], ["frac", "Carlos", "Hana", 2, null], ["frac", "Mei", "Zara", 2, null], ["frac", "Diego", "Mei", 4, null]], "given": "Mei", "asked":... | null | 4 | instruct |
qualitative_reasoning | There are 6 entities labeled 0 through 5.
Read 'i rel j' as 'entity i is rel to entity j'.
Facts:
- 3 finished-by 5
- 2 after 5
- 0 finished-by 2
- 4 meets 0
- 1 overlapped-by 3
- 1 contains 5
- 0 overlapped-by 1
- 4 equals 5
What is the relation of the vertical extent of box 1 to that of box 4?
The answer is exactly ... | contains | {"calculus": "allen_y", "topic": "vertical extents of 2D boxes", "phrasing": "the relation of the vertical extent of box {i} to that of box {j}", "n_entities": 6, "hops": 5, "n_revealed": 8, "entities": [[-3, 2, 1, 3], [-1, 2, -1, 2], [-2, 3, 2, 3], [0, 2, -3, 1], [-3, -2, 0, 1], [1, 3, 0, 1]], "revealed": [[3, 5, "fin... | null | 1 | instruct |
syntax_error_detection | (START)
start
(GRAMMAR)
decl_simple -> there are det_pl_indef n_pl
det_pl_indef -> 'some'
discourse -> decl
decl -> decl_simple
are -> 'are'
there -> 'there'
n_pl -> 'scientists'
start -> root
root -> discourse '.'
(STRING)
there are some scientists some
Answer OK, INCOMPLETE, or ERROR token for the first invalid to... | ERROR some@2 | {"g": "decl_simple -> there are det_pl_indef n_pl\ndet_pl_indef -> 'some'\ndiscourse -> decl\ndecl -> decl_simple\nare -> 'are'\nthere -> 'there'\nn_pl -> 'scientists'\nstart -> root\nroot -> discourse '.'", "start": "start", "tokens": ["there", "are", "some", "scientists", "some"], "error_index": 4, "_time": 0.1059179... | null | 0 | instruct |
string_transduction | String: cbbcbabcad
Operations:
- replace a with d
- caesar shift by 3
- dedupe adjacent repeats
Answer with the final string. | fefegefg | {"mode": "program", "source": "cbbcbabcad", "ops": ["replace a with d", "caesar shift by 3", "dedupe adjacent repeats"], "noop_rate": 0.0, "exclude_spaces": false, "_time": 0.0006940364837646484, "_task": "string_transduction", "_level": 1, "_config": {"level": 1, "seed": null, "size": null, "length": 10, "n_ops": 3, "... | null | 1 | instruct |
code_analysis | Program:
```python
import random
mode, status = 'done', 'green'
def step():
global mode, status
status = random.choice(['green', 'red', 'amber', 'blue'])
if (mode != 'fail') and (mode == 'wait'):
status = random.choice(['green', 'red', 'amber', 'blue'])
else:
match status:
... | [('done', 'green'), ('idle', 'amber'), ('wait', 'blue')] | {"program": "import random\n\nmode, status = 'done', 'green'\n\ndef step():\n global mode, status\n status = random.choice(['green', 'red', 'amber', 'blue'])\n if (mode != 'fail') and (mode == 'wait'):\n status = random.choice(['green', 'red', 'amber', 'blue'])\n else:\n match status:\n ... | null | 1 | instruct |
table_equivalence | Do these tables contain the same data?
Ignore row order, column order, and table syntax; match values by column name.
Treat numeric grouping and trailing zeros as formatting, ISO and English month-name dates as dates, and — and NULL as missing. Repeated rows count.
Table A:
event_date,amount,qty
2025-07-23,576.73,394
... | Yes | {"table_a": "event_date amount company\nAug 12, 2025 1,742.47 NULL\nMay 21, 2026 344.17 Smith, Taylor and Jordan\nDec 30, 2024 1,367.22 Bennett and Sons\nDec 30, 2024 1,367.22 Bennett and Sons", "table_b": "event_date: 2024-12-30; company: Bennett and Sons; amount: 1367.22\nevent_date: 2025-08-12; compa... | null | 0 | few_shot |
graph_successors | For each query (x, k), give the k-th successor of x by following directed edges k times.
Answer with space-separated integers in query order.
Graph:
Nodes [0, 1, 2, 3, 4, 5, 6, 7] and directed edges: (0, 4), (1, 6), (2, 7), (3, 1), (4, 2), (5, 0), (6, 5), (7, 3).
Queries:
[(2, 3), (0, 4)] | 1 3 | {"graph_description": "Nodes [0, 1, 2, 3, 4, 5, 6, 7] and directed edges: (0, 4), (1, 6), (2, 7), (3, 1), (4, 2), (5, 0), (6, 5), (7, 3).", "queries": [[2, 3], [0, 4]], "payload": {"graph": "Nodes [0, 1, 2, 3, 4, 5, 6, 7] and directed edges: (0, 4), (1, 6), (2, 7), (3, 1), (4, 2), (5, 0), (6, 5), (7, 3).", "queries": "... | null | 2 | instruct |
code_runnability | Predict whether this Python call runs successfully or raises an exception.
```python
def f0(f: int, q: list) -> list:
f = f1(q, "cat") // f
return q
def f1(f: list, z: str) -> int:
a = f2(2) + f2(0)
return 0
def f2(i: int) -> str:
print(i)
return ""
def endpoint(x0: int, x1: list) -> list:
r... | ZeroDivisionError | {"code": "def f0(f: int, q: list) -> list:\n f = f1(q, \"cat\") // f\n return q\ndef f1(f: list, z: str) -> int:\n a = f2(2) + f2(0)\n return 0\ndef f2(i: int) -> str:\n print(i)\n return \"\"\ndef endpoint(x0: int, x1: list) -> list:\n return f0(x0, x1)\n", "args": [0, [1]], "call": "endpoint(0, [... | null | 2 | instruct |
graph_pathfinding | Find the shortest directed path from node 5 to node 0. If several paths are tied, return the lexicographically smallest one. Answer with space-separated nodes, or `None` if no path exists.
Graph:
Adjacency Dictionary (source to targets): {0: [1, 3], 1: [2, 5], 2: [0, 1, 3, 4], 3: [0, 2, 4, 5], 4: [1, 3, 5], 5: [0, 3]} | 5 0 | {"weighted": false, "graph_description": "Adjacency Dictionary (source to targets): {0: [1, 3], 1: [2, 5], 2: [0, 1, 3, 4], 3: [0, 2, 4, 5], 4: [1, 3, 5], 5: [0, 3]}", "start_node": 5, "end_node": 0, "payload": {"graph": "Adjacency Dictionary (source to targets): {0: [1, 3], 1: [2, 5], 2: [0, 1, 3, 4], 3: [0, 2, 4, 5],... | null | 0 | instruct |
graph_successors | For each query (x, k), give the k-th successor of x by following directed edges k times.
Answer with space-separated integers in query order.
Graph:
Directed Edges: 0->7, 1->4, 2->2, 3->8, 4->6, 5->0, 6->1, 7->3, 8->5
Queries:
[(8, 4), (8, 3), (1, 4)] | 3 7 4 | {"graph_description": "Directed Edges: 0->7, 1->4, 2->2, 3->8, 4->6, 5->0, 6->1, 7->3, 8->5", "queries": [[8, 4], [8, 3], [1, 4]], "payload": {"graph": "Directed Edges: 0->7, 1->4, 2->2, 3->8, 4->6, 5->0, 6->1, 7->3, 8->5", "queries": "[(8, 4), (8, 3), (1, 4)]"}, "nodes": [0, 1, 2, 3, 4, 5, 6, 7, 8], "edges": [[0, 7], ... | null | 3 | instruct |
set_missing_element | Answer with the missing elements in the ordered span of ['2021-05-18', '2021-05-17', '2021-05-16', '2021-05-19', '2021-05-11', '2021-05-15', '2021-05-13', '2021-05-12', '2021-05-14'] as a Python set. | {} | {"element_list": ["2021-05-18", "2021-05-17", "2021-05-16", "2021-05-19", "2021-05-11", "2021-05-15", "2021-05-13", "2021-05-12", "2021-05-14"], "missing_count": 0, "_time": 0.00035500526428222656, "_task": "set_missing_element", "_level": 1, "_config": {"level": 1, "seed": null, "size": null, "domain_size": 300, "set_... | null | 1 | instruct |
planar_geometry_relations | Given points: C=(-8, 5); D=(11, -6); G=(8, -11/2); H=(-8, -6); M=(8, 1); N=(1, -2); V=(8, 2); Y=(-6, 2).
Definitions: S is the translation of H by vector NV. K is the projection of V onto line NS. A is the translation of S by vector KV. T is the translation of K by vector YA.
Question: What type of angle is angle DGK?
... | obtuse | {"points": {"C": "(-8, 5)", "D": "(11, -6)", "G": "(8, -11/2)", "H": "(-8, -6)", "M": "(8, 1)", "N": "(1, -2)", "V": "(8, 2)", "Y": "(-6, 2)"}, "definitions": ["S is the translation of H by vector NV.", "K is the projection of V onto line NS.", "A is the translation of S by vector KV.", "T is the translation of K by ve... | null | 2 | instruct |
regex_reasoning | A = a|c|c?
B = b?|bbb
Do A and B accept exactly the same set of strings?
The answer is Yes or No. | No | {"qtype": "equivalence", "regex_a": "a|c|c?", "regex_b": "b?|bbb", "_time": 0.009298086166381836, "_task": "regex_reasoning", "_level": 0, "_config": {"level": 0, "seed": null, "size": null, "max_depth": 4, "min_depth": 2, "n_alpha": 3, "gramforge_algorithm": "sequential"}, "_prompt_tokens": 33, "_answer_tokens": 1, "_... | null | 0 | instruct |
sequential_induction | Infer U[n]. Max recurrence degree: 0. Ops: +, -, *.
Use n. Give the simplified polynomial RHS.
Sequence: [1, 5, 11, 19, 29, 41, 55, 71, 89, 109, 131, 155, 181, 209]
The answer is the RHS only. | n**2 + 3 * n + 1 | {"first elements": [1, 5, 11, 19, 29, 41, 55, 71, 89, 109, 131, 155, 181, 209], "degree of recursion": 0, "initial terms": [], "canonical cost": 7, "canonical max cost": 7, "_time": 0.06991958618164062, "_task": "sequential_induction", "_level": 3, "_config": {"level": 3, "seed": null, "size": null, "mode": "simple", "... | null | 3 | instruct |
multistep_abduction | Premise:
[0] clara is approved.
[1] alice is careful.
[2] Being approved implies being active.
[3] From x is active, it follows that x is not trained.
Hypothesis:
david is trained.
Candidate Facts:
[0] david is approved.
[1] david is trained.
[2] david is not approved.
[3] clara is active.
[4] alice is approved.
[5] ... | 0 | {"premise": ["clara is approved.", "alice is careful.", "Being approved implies being active.", "From x is active, it follows that x is not trained."], "hypothesis": "david is trained.", "candidates": ["david is approved.", "david is trained.", "david is not approved.", "clara is active.", "alice is approved.", "alice ... | null | 0 | instruct |
analogical_case_matching | Which case matches Query under consistent entity/relation renaming and per-relation direction reversal? Answer with its ID.
M0: e alpha c, d beta e, a gamma b, e gamma d
M1: e alpha d, b beta a, c beta b, d beta a
M2: e alpha a, e alpha b, d beta a, e gamma d
M3: a alpha c, a beta c, d gamma a, d gamma c
Query: y delt... | M0 | {"cases": [{"id": "M0", "context": [["alpha", "e", "c"], ["beta", "d", "e"], ["gamma", "a", "b"], ["gamma", "e", "d"]], "consequence": ["gamma", "d", "e"]}, {"id": "M1", "context": [["alpha", "e", "d"], ["beta", "b", "a"], ["beta", "c", "b"], ["beta", "d", "a"]], "consequence": ["beta", "a", "d"]}, {"id": "M2", "contex... | null | 1 | instruct |
most_probable_outcome | A jar contains 9 green marbles and 6 yellow marbles.
Two marbles are picked without replacing the first marble.
Which statement is more likely?
A: at least one selected marble is green.
B: both selected marbles are yellow.
The answer is exactly one of: A, B, equal. | A | {"problog": "0.6::d1_x; 0.4::d1_y.\n0.571428571429::d2_x; 0.428571428571::d2_y :- d1_x.\n0.642857142857::d2_x; 0.357142857143::d2_y :- d1_y.\na :- d1_x.\na :- d2_x.\nb :- d1_y, d2_y.\nquery(a).\nquery(b).", "english": "A jar contains 9 green marbles and 6 yellow marbles.\nTwo marbles are picked without replacing the fi... | null | 4 | instruct |
parsing_derivation | (START)
start
(GRAMMAR)
R0: does -> 'does'
R1: wh_obj -> 'what'
R2: np_sg_subj -> pro_sg_subj
R3: question -> wh_obj does np_sg_subj v_trans_base
R4: root -> question '?'
R5: start -> root
R6: v_trans_base -> 'like'
R7: pro_sg_subj -> 'she'
(STRING)
what does she like ?
(QUESTION)
The answer is the rule labels used ... | R5 R4 R3 R1 R0 R2 R7 R6 | {"label": "unambiguous", "tokens": ["what", "does", "she", "like", "?"], "g": "question -> wh_obj does np_sg_subj v_trans_base\ndoes -> 'does'\nwh_obj -> 'what'\npro_sg_subj -> 'she'\nv_trans_base -> 'like'\nroot -> question '?'\nnp_sg_subj -> pro_sg_subj\nstart -> root", "start": "start", "labeled_g": "R0: does -> 'do... | null | 2 | instruct |
grid_navigation | Grid [0,7]x[0,7], N=+y, E=+x.
Initial Facts:
- D is below B.
- D starts at (3, 2).
- E is right of F.
- A is above D.
- D is above E.
- B is right of A.
- F starts at (1, 5).
- B is right of F.
- C is below F.
- E is below F.
- C is left of B.
Steps:
1. E jumps to A's position offset by (-1, 0).
2. F jumps to B's posi... | Yes | {"answer_type": "distance", "query_a": "A", "query_b": "C", "grid": 7, "objects": ["A", "B", "C", "D", "E", "F"], "facts": [{"k": "v", "a": "D", "b": "B", "r": "below"}, {"k": "coord", "a": "D", "p": [3, 2]}, {"k": "h", "a": "E", "b": "F", "r": "right"}, {"k": "v", "a": "A", "b": "D", "r": "above"}, {"k": "v", "a": "D"... | null | 3 | verification |
constraint_satisfaction | In this 5x5 grid, each row and column contains 1..5 once.
Constraints:
1. r1c3 < r1c4
2. r4c3 < r4c2
3. r5c5 != 1
4. r2c1 = 5
5. r4c4 = 1
6. r4c1 < r5c1
7. r3c3 < r4c3
Question: What is r5c2?
Answer with one name or integer. | 1 | {"model_mode": "grid", "family": "grid", "solve_mode": "query", "query_type": "scalar", "structure_mode": null, "query": [5, 2], "query_var": "r5c2", "clues": ["r1c3 < r1c4", "r4c3 < r4c2", "r5c5 != 1", "r2c1 = 5", "r4c4 = 1", "r4c1 < r5c1", "r3c3 < r4c3"], "constraints": ["r1c3 < r1c4", "r4c3 < r4c2", "r5c5 != 1", "r2... | null | 3 | instruct |
code_execution | Predict the value returned by this Python call.
```python
def f0(a: str) -> list:
a = f1(4, [0, 1, 2])
return []
def f1(z: int, u: list) -> str:
if z > z:
z = z + 1
pass
return ""
def endpoint(x0: str) -> list:
return f0(x0)
```
Call: `endpoint('cyz')`
The answer is the exact Python `re... | [] | {"code": "def f0(a: str) -> list:\n a = f1(4, [0, 1, 2])\n return []\ndef f1(z: int, u: list) -> str:\n if z > z:\n z = z + 1\n pass\n return \"\"\ndef endpoint(x0: str) -> list:\n return f0(x0)\n", "args": ["cyz"], "call": "endpoint('cyz')", "steps": 6, "elapsed": 0.0013944140009698458, "stdou... | null | 1 | instruct |
combinatorics_formula_selection | Which expression counts the outcomes? Answer A-D.
C(n,k): unordered; P(n,k): ordered.
Problem:
Choose exactly one item from disjoint groups of sizes 9 and 7.
Options:
A. 9*7
B. 9+7
C. 2*9*7
D. 9+7-1 | B | {"family": "sum_rule", "structural_depth": 1, "program_type": "ChoiceRule", "program": {"kind": "sum", "first": 9, "second": 7}, "correct_expression": "9+7", "correct_option_index": 1, "correct_features": {"top_operator": "sum", "ast_size": 3, "contains_combination": false, "contains_permutation": false, "contains_powe... | null | 2 | instruct |
logic_nli | Premise:
Roger is the only person in the room.
if “Bellbridge's houses are all purple.” then ““The clock tower in Chronos does not strike thirteen times.” or “The lighthouse on Cape Sorrow glows green.” but not both”
Jesus is hotel tagged
Jesus is bravo tagged
no quiet person in the room is quiet
The clock tower in Chr... | No | {"verbalize_seed": 396728, "proof": {"proof": "% Running in auto input_syntax mode. Trying TPTP\n% Refutation found. Thanks to Tanya!\n% SZS status Unsatisfiable for tmpmqbujn36\n% SZS output start Proof for tmpmqbujn36\n2. room(roger) & ! [X0] : (room(X0) => X0 = roger) [input(axiom) 0]\n6. ! [X0] : (room(X0) => (quie... | null | 0 | instruct |
code_execution | Predict the value returned by this Python call.
```python
def f0(b: list, m: str) -> list:
a = 2
try:
print(a)
except Exception:
while a <= 3:
b = [k % 3 for k in range(5, 7)]
a = a + 2
return b
def f1(r: str) -> str:
try:
pass
except Exception:
... | [2] | {"code": "def f0(b: list, m: str) -> list:\n a = 2\n try:\n print(a)\n except Exception:\n while a <= 3:\n b = [k % 3 for k in range(5, 7)]\n a = a + 2\n return b\ndef f1(r: str) -> str:\n try:\n pass\n except Exception:\n b = [w + 2 for w in range(4, ... | null | 2 | instruct |
string_transduction | String: gedcbcggaagcgbcf
Operations:
- reverse
- dedupe adjacent repeats
- replace d with c
- rotate left by 2
- sort ascending
- sort descending
Answer with the final string.
Answer:
ggggfecccccbba
Correct? (Yes/No) | Yes | {"mode": "program", "source": "gedcbcggaagcgbcf", "ops": ["reverse", "dedupe adjacent repeats", "replace d with c", "rotate left by 2", "sort ascending", "sort descending"], "noop_rate": 0.0, "exclude_spaces": false, "_time": 0.0014531612396240234, "_task": "string_transduction", "_level": 4, "_config": {"level": 4, "s... | null | 4 | verification |
metamath_entailment | Does the conjecture follow using only the listed premises and rules?
Rules instantiate only by renaming variables.
The answer is True or False.
Premises:
1. ctx => P2(x, D1)
2. ctx => P2(y, D2)
3. ctx => P3(y, C0)
Allowed Rules:
r1: ctx => P2(x, D3); ctx => P2(y, D3); ctx => P3(y, C0) ==> ctx => P4(F2(F1(y, x), y), x... | True | {"premises": ["ctx => P2(x, D1)", "ctx => P2(y, D2)", "ctx => P3(y, C0)"], "raw_premises": [["|-", "(", "ph", "->", "A", "e.", "NN", ")"], ["|-", "(", "ph", "->", "B", "e.", "NN0", ")"], ["|-", "(", "ph", "->", "B", "=/=", "0", ")"]], "rules": ["r1", "r2", "r3", "r4"], "raw_rule_labels": ["divcan3d", "nn0cnd", "nnzd", ... | null | 1 | instruct |
set_expression | B = {'one', 'thirty', 'thirteen', 'thirty-three', 'forty', 'eighteen', 'forty-three', 'five', 'twenty-one'}
C = {'five', 'seven', 'forty-three', 'twenty-three', 'eighteen', 'fourteen', 'forty-seven', 'ten', 'twenty'}
Evaluate (C & B). | {'eighteen', 'five', 'forty-three'} | {"expr": "(C & B)", "list_mode": false, "C": ["five", "seven", "forty-three", "twenty-three", "eighteen", "fourteen", "forty-seven", "ten", "twenty"], "B": ["one", "thirty", "thirteen", "thirty-three", "forty", "eighteen", "forty-three", "five", "twenty-one"], "_time": 0.0005443096160888672, "_task": "set_expression", ... | null | 1 | instruct |
reference_tracking | Rules:
- Each ball has a positive integer size.
- Dock(X, Y) succeeds iff size(X) == size(Y).
- If docking fails and the failure sentence says 'it was too large/small',
'it' refers to the larger/smaller of the two docked balls.
Inventory:
- b1: black
- b2: green
- b3: black
- b4: green
- b5: yellow
Initial State:
-... | No | {"family": "logical_winograd", "balls": ["b1", "b2", "b3", "b4", "b5"], "boxes": ["x1", "x2", "x3", "x4"], "colors": {"b1": "black", "b2": "green", "b3": "black", "b4": "green", "b5": "yellow"}, "initial_placement": {"b1": "x2", "b2": "x1", "b3": "x4", "b4": "x3", "b5": "x4"}, "moves": ["Transfer b4 from x3 into x2.", ... | null | 2 | verification |
parsing_derivation | (START)
start
(GRAMMAR)
R0: seq -> expr seq
R1: expr -> '<' seq '>'
R2: start -> seq
R3: seq ->
R4: expr -> '(' seq ')'
R5: expr -> '[' seq ']'
(STRING)
( ) ( )
(QUESTION)
The answer is the rule labels used in the leftmost derivation of STRING, in order, separated by spaces.
Answer:
R2 R0 R4 R3 R0 R4 R3 R3
(START)... | R2 R4 R0 R1 R4 R3 R1 R4 R5 R1 R1 | {"label": "unambiguous", "tokens": ["(", ")", "[", "]", "<", ">"], "g": "seq -> expr seq\nexpr -> '[' seq ']'\nexpr -> '<' seq '>'\nexpr -> '(' seq ')'\nstart -> seq\nseq -> ", "start": "start", "labeled_g": "R0: expr -> '(' seq ')'\nR1: seq -> \nR2: start -> seq\nR3: expr -> '[' seq ']'\nR4: seq -> expr seq\nR5: expr ... | null | 3 | few_shot |
regex_reasoning | A = abac
B = (a)ab+
Is every string accepted by A also accepted by B?
The answer is Yes or No.
Answer:
aaddbb
Correct? (Yes/No) | No | {"qtype": "containment", "regex_a": "abac", "regex_b": "(a)ab+", "_time": 0.011043071746826172, "_task": "regex_reasoning", "_level": 0, "_config": {"level": 0, "seed": null, "size": null, "max_depth": 4, "min_depth": 2, "n_alpha": 3, "gramforge_algorithm": "sequential"}, "_prompt_tokens": 30, "_answer_tokens": 1, "_ge... | null | 0 | verification |
unification_entailment | Compute a most general unifier of the equations. Apply it to both sides of the candidate equality. Answer Yes if the instantiated candidate terms are identical, otherwise answer No. The equations are guaranteed to be unifiable.
Equations:
- g(x0) = g(c)
Candidate:
x0 = g(c) | No | {"answer": "No", "equations": ["g(x0) = g(c)"], "candidate": "x0 = g(c)", "num_equations": 1, "num_variables": 1, "num_bindings_in_mgu": 1, "max_term_depth": 1, "candidate_depth": 1, "trace_steps": 2, "num_decompositions": 1, "num_alias_bindings": 0, "num_sharing_constraints": 0, "num_redundant_equations": 0, "difficul... | null | 0 | instruct |
constrained_continuation | (START)
start
(GRAMMAR)
seq ->
expr -> '[' seq ']'
expr -> '(' seq ')'
expr -> '<' seq '>'
seq -> expr seq
start -> seq
(PREFIX)
<
(TEMPLATE)
< ___ ___
(SUFFIX)
[ ] < > ( )
Fill in the 2 blanks (___) so that PREFIX + filled-TEMPLATE + SUFFIX is a grammatical sentence.
Answer with the blank tokens in order, space-... | > > | {"g": "seq -> \nexpr -> '[' seq ']'\nexpr -> '(' seq ')'\nexpr -> '<' seq '>'\nseq -> expr seq\nstart -> seq", "start": "start", "k": 3, "prefix": ["<"], "suffix": ["[", "]", "<", ">", "(", ")"], "hints": {"0": "<"}, "template": "< ___ ___", "blanks": [1, 2], "n_blanks": 2, "n_hints": 1, "n_options": 6, "_time": 0.0623... | null | 3 | instruct |
arithmetics | Evaluate lcm(7, 59) + abs(12) + -4.60.
The answer is a number. | 420.4 | {"expr": "lcm(7, 59) + abs(12) + -4.60", "display_expr": "lcm(7, 59) + abs(12) + -4.60", "digit_mode": "normal", "semantics": "exact", "semantic_cue": false, "out_decimals": 3, "height": 5, "cot": "lcm(7, 59) = 413\nabs(12) = 12\n413 + 12 = 425\n425 + -4.6 = 420.4", "_time": 0.0016937255859375, "_task": "arithmetics", ... | null | 0 | instruct |
planning | Objects:
object_1, object_2, object_3, object_4
Actions:
action_0(x0, x1)
Effect: fluent_2(x1, x0)
action_3(x0, x1)
Requires: fluent_2(x1, x0), fluent_0(x0)
Effect: fluent_5(x0), fluent_1(x1, x0)
Initial state:
True values: fluent_0(object_4)
All facts not listed under True values are false.
Goal:
fluent_1(obj... | action_0(object_4, object_1)
action_0(object_4, object_4)
action_0(object_4, object_2)
action_0(object_3, object_3)
action_3(object_4, object_2) | {"domain_seed": "8-280", "fluent_arity": 2, "na": 5, "planted_na": 5, "optimality_gap": 0, "target_na": 5, "generator_mode": "planted_walk_optimal", "trim_mode": "plan_cone", "problem_english": "Objects:\nobject_1, object_2, object_3, object_4\n\nActions:\naction_0(x0, x1)\n Effect: fluent_2(x1, x0)\naction_3(x0, x1)\... | null | 4 | instruct |
metamath_entailment | Does the conjecture follow using only the listed premises and rules?
Rules instantiate only by renaming variables.
The answer is True or False.
Premises:
1. ctx => P2(F1(x, C2), D1)
2. ctx => P2(x, D2)
3. ctx => P2(x, D3)
4. ctx => P2(F2(x), D4)
5. ctx => P3(C0, x)
6. ctx => P4(x, C0)
7. ctx => P2(x, D5)
8. ctx => P5(... | False | {"premises": ["ctx => P2(F1(x, C2), D1)", "ctx => P2(x, D2)", "ctx => P2(x, D3)", "ctx => P2(F2(x), D4)", "ctx => P3(C0, x)", "ctx => P4(x, C0)", "ctx => P2(x, D5)", "ctx => P5(y, C0)"], "raw_premises": [["|-", "(", "ph", "->", "(", "A", "^", "2", ")", "e.", "ZZ", ")"], ["|-", "(", "ph", "->", "A", "e.", "QQ", ")"], ["... | null | 2 | instruct |
graph_successors | For each query (x, k), give the k-th successor of x by following directed edges k times.
Answer with space-separated integers in query order.
Graph:
Nodes [0, 1, 2, 3, 4, 5, 6, 7] and directed edges: (0, 4), (1, 6), (2, 7), (3, 1), (4, 2), (5, 0), (6, 5), (7, 3).
Queries:
[(2, 3), (0, 4)]
Answer:
1 3
For each query ... | 3 6 | {"graph_description": "Directed Edges: 0->3, 1->7, 2->5, 3->1, 4->0, 5->4, 6->6, 7->2", "queries": [[0, 1], [6, 4]], "payload": {"graph": "Directed Edges: 0->3, 1->7, 2->5, 3->1, 4->0, 5->4, 6->6, 7->2", "queries": "[(0, 1), (6, 4)]"}, "nodes": [0, 1, 2, 3, 4, 5, 6, 7], "edges": [[0, 3], [1, 7], [2, 5], [3, 1], [4, 0],... | null | 2 | few_shot |
most_probable_evidence | Factor d is independently true with probability 0.1.
Factor f is independently true with probability 0.3.
Factor b is independently true with probability 0.7.
The observation holds exactly when ((factor d or factor f) holds and factor b is false).
We observe it.
Which hidden fact values form the most probable complete ... | 1 3 4 | {"problog": "0.1::d.\n0.3::f.\n0.7::b.\nobserved :- ((d;f),\\+b).\nevidence(observed,true).", "english": "Factor d is independently true with probability 0.1.\nFactor f is independently true with probability 0.3.\nFactor b is independently true with probability 0.7.\nThe observation holds exactly when ((factor d or fac... | null | 1 | instruct |
constrained_continuation | (START)
start
(GRAMMAR)
expr -> '(' seq ')'
start -> seq
seq ->
expr -> '<' seq '>'
seq -> expr seq
expr -> '[' seq ']'
(PREFIX)
<empty>
(TEMPLATE)
___ > ___ >
(SUFFIX)
<empty>
Fill in the 2 blanks (___) so that PREFIX + filled-TEMPLATE + SUFFIX is a grammatical sentence.
Answer with the blank tokens in order, sp... | < < | {"g": "expr -> '(' seq ')'\nstart -> seq\nseq -> \nexpr -> '<' seq '>'\nseq -> expr seq\nexpr -> '[' seq ']'", "start": "start", "k": 4, "prefix": [], "suffix": [], "hints": {"1": ">", "3": ">"}, "template": "___ > ___ >", "blanks": [0, 2], "n_blanks": 2, "n_hints": 2, "n_options": 18, "_time": 0.0758662223815918, "_ta... | null | 1 | instruct |
program_synthesis | Write f(s: str) -> str.
Target: return the minimum-cost StringFrag-v1 expression matching the examples.
Always allowed: s, string literals "", " ", "-", "_", and integer literals 0, 1, 2, 3.
Allowed operators for this problem:
- replace1: str.replace(str, str, 1)
- find: str.find(str)
- eq_str: str == str
Bounds: str... | def f(s: str) -> str:
return s.replace("_", "-", 1) | {"dsl": "StringFrag-v1", "cost": "nodes,ops,source_len,source_lex", "max_nodes": 11, "io_pairs": [[" abc", " abc"], ["__", "-_"]], "examples": [[" abc", " abc"], ["__", "-_"]], "holdout": [["", ""], [" ", " "], ["-", "-"], ["_", "-"], ["a", "a"], ["aa", "aa"], ["ab", "ab"], ["a-b", "a-b"], ["a_b", "a-b"], ["abc", "abc"... | null | 1 | instruct |
planning | Objects:
object_1, object_2, object_3, object_4, object_5
Actions:
action_0(x0, x1)
Requires: fluent_0(x1, x0), fluent_0(x0, x1)
Effect: not fluent_3
action_1(x0, x1)
Requires: fluent_4
Effect: fluent_2(x0)
action_2(x0, x1)
Requires: fluent_1(x0, x1), fluent_0(x0, x1), fluent_5
Effect: fluent_4, not fluent... | action_1(object_1, object_2)
action_1(object_4, object_2)
action_4(object_2, object_1)
action_1(object_2, object_2)
action_4(object_1, object_2)
action_4(object_4, object_4) | {"domain_seed": "7-311", "fluent_arity": 2, "na": 6, "planted_na": 6, "optimality_gap": 0, "target_na": 5, "generator_mode": "planted_walk_optimal", "trim_mode": "full", "problem_english": "Objects:\nobject_1, object_2, object_3, object_4, object_5\n\nActions:\naction_0(x0, x1)\n Requires: fluent_0(x1, x0), fluent_0(x... | null | 3 | instruct |
planar_geometry_relations | Given points: N=(3, -2); O=(-2, -3); Q=(5/9, 23/9); R=(-1, -1); S=(1/9, 31/9); W=(-3, -4); Z=(4, -3).
Definitions: J is the 90-degree counterclockwise rotation of W about R. K is the 90-degree counterclockwise rotation of N about R.
Question: What type of angle is angle SKQ?
Answer is one of: acute, right, obtuse. | obtuse | {"points": {"N": "(3, -2)", "O": "(-2, -3)", "Q": "(5/9, 23/9)", "R": "(-1, -1)", "S": "(1/9, 31/9)", "W": "(-3, -4)", "Z": "(4, -3)"}, "definitions": ["J is the 90-degree counterclockwise rotation of W about R.", "K is the 90-degree counterclockwise rotation of N about R."], "query": "What type of angle is angle SKQ?"... | null | 0 | instruct |
analogical_case_matching | Which case matches Query under consistent entity/relation renaming and per-relation direction reversal? Answer with its ID.
M0: a beta b, b beta c, c beta a, d beta a
M1: b alpha a, b alpha c, c alpha d, a beta d
M2: b alpha d, c alpha a, d alpha c, c beta b
M3: e alpha b, a beta c, c beta d, e beta f
Query: u delta z... | M2 | {"cases": [{"id": "M0", "context": [["beta", "a", "b"], ["beta", "b", "c"], ["beta", "c", "a"], ["beta", "d", "a"]], "consequence": ["beta", "a", "d"]}, {"id": "M1", "context": [["alpha", "b", "a"], ["alpha", "b", "c"], ["alpha", "c", "d"], ["beta", "a", "d"]], "consequence": ["alpha", "a", "b"]}, {"id": "M2", "context... | null | 1 | instruct |
grid_navigation | Grid [0,8]x[0,8], N=+y, E=+x.
Initial Facts:
- E is left of A.
- A is right of F.
- F starts at (1, 5).
- A is left of G.
- F is left of B.
- B is right of E.
- A is in the same column as D.
- G is below D.
- B is left of C.
- F is above E.
- E is in the same column as F.
Steps:
1. G jumps to B's position offset by (1... | (aligned, above) | {"answer_type": "relation", "query_a": "A", "query_b": "F", "grid": 8, "objects": ["A", "B", "C", "D", "E", "F", "G"], "facts": [{"k": "h", "a": "E", "b": "A", "r": "left"}, {"k": "h", "a": "A", "b": "F", "r": "right"}, {"k": "coord", "a": "F", "p": [1, 5]}, {"k": "h", "a": "A", "b": "G", "r": "left"}, {"k": "h", "a": ... | null | 4 | instruct |
belief_tracking | Initially, everyone knows that the coin is in the tray.
Story: Heidi moves the coin to the tray. No one else sees the move. Dave sends Carol the message "I think the coin is in the tray", but it is not delivered. Dave moves the coin to the tray. Unknown to the others, Carol watches through a window. Dave moves the coi... | tray | {"agents": ["Carol", "Dave", "Heidi"], "objects": ["coin"], "containers": ["vase", "jar", "tray"], "init": {"loc": {"coin": "tray"}}, "specs": [{"kind": "move", "actor": "Heidi", "target": null, "policy": null, "report_type": null, "scene": "private_observation", "object": "coin", "destination": "tray", "observers": []... | null | 1 | instruct |
code_runnability | Predict whether this Python call runs successfully or raises an exception.
```python
def f0(r: list, j: int) -> int:
j *= (4 if 2 * j > False else j)
j *= 3
j = j * 3
j += f1(j)
j = r.index(j)
return j + 3
def f1(b: int) -> int:
b += b
return b * 9
def f2(w: str, c: str) -> list:
pri... | ValueError | {"code": "def f0(r: list, j: int) -> int:\n j *= (4 if 2 * j > False else j)\n j *= 3\n j = j * 3\n j += f1(j)\n j = r.index(j)\n return j + 3\ndef f1(b: int) -> int:\n b += b\n return b * 9\ndef f2(w: str, c: str) -> list:\n print(c)\n return []\ndef endpoint(x0: list, x1: int) -> int:\n ... | null | 1 | instruct |
graph_successors | For each query (x, k), give the k-th successor of x by following directed edges k times.
Answer with space-separated integers in query order.
Graph:
Nodes: [0, 1, 2, 3, 4, 5, 6, 7, 8]
Adjacency Matrix (row indicates source, column indicates target):
[0, 0, 0, 0, 0, 0, 1, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, ... | 5 8 | {"graph_description": "Nodes: [0, 1, 2, 3, 4, 5, 6, 7, 8]\nAdjacency Matrix (row indicates source, column indicates target):\n[0, 0, 0, 0, 0, 0, 1, 0, 0]\n[0, 0, 1, 0, 0, 0, 0, 0, 0]\n[0, 0, 0, 0, 0, 0, 0, 0, 1]\n[0, 0, 0, 0, 0, 0, 0, 1, 0]\n[0, 0, 0, 1, 0, 0, 0, 0, 0]\n[0, 0, 0, 0, 0, 1, 0, 0, 0]\n[1, 0, 0, 0, 0, 0, 0... | null | 3 | instruct |
equation_system | Solve the following system of equations for the variable 'X1'.
System:
X1 + X2 - 25 = 0
-6*X1 - 7*X2 + 166 = 0
2*X1 + 3*X2 - 66 = 0
The answer is the value of X1, or 'No solution' / 'Multiple solutions'. | 9 | {"equations": ["X1 + X2 - 25 = 0", "-6*X1 - 7*X2 + 166 = 0", "2*X1 + 3*X2 - 66 = 0"], "query_variable": "X1", "full_solution_map": {"X1": 9, "X2": 16}, "case": "unique", "cot": "1. Forward:\nR2 -= -6*R1\nR3 -= 2*R1\nR3 -= -1*R2\n\n2. Backward:\nX2 = 16\nX1 = 9", "_time": 0.027585744857788086, "_task": "equation_system"... | null | 0 | instruct |
set_missing_element | Answer with the missing elements in the ordered span of [610, 614, 613, 615, 612] as a Python set. | {611} | {"element_list": [610, 614, 613, 615, 612], "missing_count": 1, "_time": 0.0009310245513916016, "_task": "set_missing_element", "_level": 0, "_config": {"level": 0, "seed": null, "size": null, "domain_size": 200, "set_size": 6, "n_domains": 2, "prob_no_missing": 0.1}, "_prompt_tokens": 30, "_answer_tokens": 3, "_genera... | null | 0 | instruct |
End of preview. Expand in Data Studio
Task gallery · Source · Paper · RLVR dataset
Procedural Pile is a synthetic corpus of verifiable reasoning problems generated by Reasoning Core. It is intended for continued pretraining, mid-training, and supervised fine-tuning.
Answers come from procedural generators and task-specific solvers or checkers, rather than language-model generation. The corpus spans mathematics, formal logic, planning, graphs, parsing, code, structured data, and other symbolic domains. Difficulty is controlled continuously within each task.
Reasoning Core is optimized for transferability: task selection and difficulty ranges are guided by reproducible measurements of transfer, solvability, and shortcut resistance.
Load
from datasets import load_dataset
dataset = load_dataset("reasoning-core/procedural-pile")
No configuration name is required. The dataset provides train and test splits.
Dataset structure
| Field | Description |
|---|---|
task |
Reasoning task identifier |
prompt |
Model input |
answer |
Canonical target answer |
metadata |
JSON-encoded generation and validation metadata |
level |
Difficulty level |
mode |
instruct, few_shot, or verification |
Most examples use direct instruction format. A smaller share adds one in-context demonstration or asks the model to verify a candidate answer.
Task catalogue
The corpus currently contains 50 task families. The task gallery includes a worked example for each one.
| Area | Tasks |
|---|---|
| Mathematics & formal methods · 10 | arithmetics · math_word_problem · equation_system · combinatorics_formula_selection · planar_geometry_relations · lean_candidate_compilation · lean_missing_line · metamath_core_select · metamath_entailment · sequential_induction |
| Logic & inference · 10 | logic_formalization · logic_nli · logic_qa · defeasible_nli · multistep_nli · multistep_abduction · multistep_evidence_retrieval · qualitative_reasoning · qualitative_causal_reasoning · belief_tracking |
| Symbolic transformations · 7 | lambda_reduction · rewrite_system · unification_entailment · set_expression · set_missing_element · string_transduction · analogical_case_matching |
| Planning, state & graphs · 7 | planning · constraint_satisfaction · grid_navigation · reference_tracking · coreference · graph_pathfinding · graph_successors |
| Language & formal languages · 5 | parsing_derivation · regex_following · regex_reasoning · constrained_continuation · syntax_error_detection |
| Structured data & code · 7 | table_qa · table_equivalence · table_statistics · code_analysis · code_execution · code_runnability · program_synthesis |
| Games & probability · 4 | game_best_move · game_forced_win · most_probable_evidence · most_probable_outcome |
Citation
@article{reasoningcore2026,
title = {Reasoning Core: A Scalable Procedural Data Generation Suite for Symbolic Pre-training and Post-Training},
author = {Lacombe, Valentin and Quesnel, Valentin and Sileo, Damien},
journal = {arXiv preprint arXiv:2603.02208},
year = {2026},
url = {https://arxiv.org/abs/2603.02208}
}
- Downloads last month
- 2,731