datasets
Collection
Reasoning Core ◉
Pre-generated symbolic reasoning data, from pre-training pile to post-training environments • 7 items • Updated • 4
Datasets:
task large_stringclasses 51
values | prompt large_stringlengths 38 10.7k | answer large_stringlengths 1 3.36k | metadata large_stringlengths 634 33k | level int64 0 6 | mode large_stringclasses 1
value |
|---|---|---|---|---|---|
metamath_entailment | Which premise set makes the conjecture follow using only the listed rules?
Exactly one of A and B is sufficient.
Rules instantiate only by renaming variables.
The answer is A or B.
Premise Set A:
1. ctx => P2(x, D1)
2. ctx => P3(C0, x)
3. ctx => P2(y, D1)
4. ctx => P4(y, C0)
Premise Set B:
1. ctx => P2(x, D1)
2. ctx ... | A | {"premise_sets": [["ctx => P2(x, D1)", "ctx => P3(C0, x)", "ctx => P2(y, D1)", "ctx => P4(y, C0)"], ["ctx => P2(x, D1)", "ctx => P3(C0, y)", "ctx => P2(y, D1)", "ctx => P4(x, C0)"]], "raw_premise_sets": [[["|-", "(", "ph", "->", "A", "e.", "RR", ")"], ["|-", "(", "ph", "->", "0", "<", "A", ")"], ["|-", "(", "ph", "->",... | 0 | instruct |
logic_derivation | Premise:
0: clara is a parent of alice.
1: alice is a parent of farah.
2: farah is a parent of elena.
3: david is a spouse of farah.
4: bruno is not a spouse of david.
5: clara is not careful.
6: david trusts bruno.
7: For all x, y, if x is a parent of y, then x is an ancestor of y.
8: From x is a parent of y and y is ... | 7: 2 => farah is an ancestor of elena
8: 1 @0 => alice is an ancestor of elena
8: 0 @1 => clara is an ancestor of elena | {"premise": ["clara is a parent of alice.", "alice is a parent of farah.", "farah is a parent of elena.", "david is a spouse of farah.", "bruno is not a spouse of david.", "clara is not careful.", "david trusts bruno.", "For all x, y, if x is a parent of y, then x is an ancestor of y.", "From x is a parent of y and y i... | 2 | instruct |
most_probable_outcome | A container has 7 red items, 7 blue items, 10 green items, 8 gold items.
Draw 5 items in sequence.
After draw 1, replace the item before the next draw.
After draw 2, do not replace the item.
After draw 3, do not replace the item.
After draw 4, do not replace the item.
We observe that the first item is not green.
Which ... | equal | {"problog": "", "english": "A container has 7 red items, 7 blue items, 10 green items, 8 gold items.\nDraw 5 items in sequence.\nAfter draw 1, replace the item before the next draw.\nAfter draw 2, do not replace the item.\nAfter draw 3, do not replace the item.\nAfter draw 4, do not replace the item.\nWe observe that t... | 5 | 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:
- substr: str[int:(int)+(int)]
- replace1: str.replace(str, str, 1)
- len: len(str)
- add: ... | def f(s: str) -> str:
return s.replace(" ", "", 1)[2:(2)+(2)] | {"dsl": "StringFrag-v1", "cost": "nodes,ops,source_len,source_lex", "max_nodes": 10, "io_pairs": [["a_b", "b"], [" abc", "c"], [" ", ""], ["a-b", "b"], ["-_cc", "cc"]], "examples": [["a_b", "b"], [" abc", "c"], [" ", ""], ["a-b", "b"], ["-_cc", "cc"]], "holdout": [["", ""], ["-", ""], ["_", ""], ["a", ""], ["aa", ""], ... | 0 | 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: n2. Turns alternate player, opponent. Move along one edge per turn, for at most 4 moves. Play ends up... | No | {"rules": "role(player).\nrole(opponent).\ninit(at(n2)).\ninit(step(t0)).\ninit(control(player)).\nsucc(t0,t1). succ(t1,t2). succ(t2,t3). succ(t3,t4).\nedge(n0,n8). edge(n1,n3). edge(n2,n8). edge(n2,n9). edge(n3,n9). edge(n4,n5). edge(n4,n7). edge(n5,n6). edge(n5,n7). edge(n6,n8). edge(n6,n9).\nleaf(n7). leaf(n8). leaf... | 3 | instruct |
most_probable_outcome | A container has 8 red items, 9 blue items, 9 green items.
Draw 4 items in sequence.
After draw 1, do not replace the item.
After draw 2, do not replace the item.
After draw 3, replace the item before the next draw.
No draw result is observed in advance.
Which statement is more likely?
A: exactly 1 draws are green.
B: e... | equal | {"problog": "", "english": "A container has 8 red items, 9 blue items, 9 green items.\nDraw 4 items in sequence.\nAfter draw 1, do not replace the item.\nAfter draw 2, do not replace the item.\nAfter draw 3, replace the item before the next draw.\nNo draw result is observed in advance.\nWhich statement is more likely?\... | 2 | 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: (?:[oFj]{1}?) | F | {"regex": "(?:[oFj]{1}?)", "string": "F", "answer_length_bucket": "1", "answer_first_kind": "upper", "_time": 0.0051915645599365234, "_task": "regex_following", "_level": 0, "_config": {"level": 0, "seed": null, "size": null, "n_ex": 8, "max_depth": 5, "min_depth": 3, "n_alpha": 4, "max_answer_len": 24, "max_synth_node... | 0 | instruct |
rule_switching | Maintain the register values while executing the program. The current mode determines each opcode's meaning. For an instruction on registers (a,b,c): rotate-left maps their values to (b,c,a); rotate-right to (c,a,b); swap-first-two to (b,a,c); swap-last-two to (a,c,b); and swap-outer to (c,b,a). Mode changes affect fol... | D | {"registers": ["r1", "r2", "r3", "r4", "r5", "r6"], "initial": {"r1": "A", "r2": "B", "r3": "C", "r4": "D", "r5": "E", "r6": "F"}, "mappings": [{"X": "swap-last-two", "Y": "rotate-right", "Z": "swap-first-two"}, {"X": "rotate-right", "Y": "swap-last-two", "Z": "swap-first-two"}, {"X": "rotate-left", "Y": "swap-first-tw... | 2 | instruct |
multistep_nli | Premise:
alice trusts bruno.
bruno is active.
alice helps clara.
Whenever x trusts y and y is active, x is approved.
From x is approved, it follows that x is trusted.
Hypothesis:
alice is not trusted.
Is the hypothesis true given the premise? The answer is Yes, No, or Maybe. | No | {"premise": ["alice trusts bruno.", "bruno is active.", "alice helps clara.", "Whenever x trusts y and y is active, x is approved.", "From x is approved, it follows that x is trusted."], "hypothesis": "alice is not trusted.", "label": "contradiction", "domain_pack": "surface", "depth": 2, "hypothesis_sign": false, "sup... | 0 | instruct |
metamath_core_select | Which option is sufficient to derive the conjecture?
Use only the listed premises and rules. No hidden background facts.
Rules may only rename variables, not substitute compound terms.
The answer is A, B, C, or D.
Premises:
1. ctx => P2(x, D1)
2. ctx => P2(y, D1)
3. ctx => P2(z, D2)
Rule Catalog:
- r1: P3(x, y) ==> P... | C | {"premises": ["ctx => P2(x, D1)", "ctx => P2(y, D1)", "ctx => P2(z, D2)"], "raw_premises": [["|-", "(", "ph", "->", "A", "e.", "CC", ")"], ["|-", "(", "ph", "->", "B", "e.", "CC", ")"], ["|-", "(", "ph", "->", "C", "e.", "ZZ", ")"]], "conjecture": "ctx => P3(F1(x, F1(y, z)), F1(y, F1(x, z)))", "raw_conjecture": ["|-", ... | 4 | 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: [3], 1: [0], 2: [5], 3: [2], 4: [1], 5: [4], 6: [7], 7: [6]}
Queries:
[(3, 2), (2, 4)] | 5 0 | {"graph_description": "Adjacency Dictionary (source to targets): {0: [3], 1: [0], 2: [5], 3: [2], 4: [1], 5: [4], 6: [7], 7: [6]}", "queries": [[3, 2], [2, 4]], "payload": {"graph": "Adjacency Dictionary (source to targets): {0: [3], 1: [0], 2: [5], 3: [2], 4: [1], 5: [4], 6: [7], 7: [6]}", "queries": "[(3, 2), (2, 4)]... | 2 | instruct |
code_analysis | Program:
```python
level, active, stage = 1, False, 'fail'
def step():
global level, active, stage
if stage != 'wait':
stage, level = 'done' if (level < 1) and (level != 2) else stage, 0 if not active else level
return
```
Start from the assignments above; each transition calls `step()`.
For... | 2 | {"program": "level, active, stage = 1, False, 'fail'\n\ndef step():\n global level, active, stage\n if stage != 'wait':\n stage, level = 'done' if (level < 1) and (level != 2) else stage, 0 if not active else level\n return\n", "predicates": "p0 := stage == 'fail'\np1 := level == 0\np2 := stage == '... | 2 | instruct |
set_missing_element | Answer with the missing elements in the ordered span of ['eight hundred and fifteen', 'eight hundred and eighteen', 'eight hundred and eleven', 'eight hundred and sixteen', 'eight hundred and thirteen', 'eight hundred and ten'] as a Python set. | {'eight hundred and fourteen', 'eight hundred and seventeen', 'eight hundred and twelve'} | {"element_list": ["eight hundred and fifteen", "eight hundred and eighteen", "eight hundred and eleven", "eight hundred and sixteen", "eight hundred and thirteen", "eight hundred and ten"], "missing_count": 3, "_time": 0.00027298927307128906, "_task": "set_missing_element", "_level": 1, "_config": {"level": 1, "seed": ... | 1 | 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:
- h(b, x4) = h(x3, x2)
- h(x0, b) = h(x5, x3)
- h(x0, x0) = h(x5, x1)
- h(b, x4)... | Yes | {"answer": "Yes", "equations": ["h(b, x4) = h(x3, x2)", "h(x0, b) = h(x5, x3)", "h(x0, x0) = h(x5, x1)", "h(b, x4) = h(b, x2)"], "candidate": "h(b, x0) = h(b, x1)", "num_equations": 4, "num_variables": 6, "num_bindings_in_mgu": 4, "max_term_depth": 1, "candidate_depth": 1, "trace_steps": 7, "num_decompositions": 3, "nu... | 1 | instruct |
equation_system | Solve the following system of equations for the variable 'X3'.
System:
-2*X1 + 4*X3 + X4 - 12 = 0
-4*X1 + 2*X2 + 9*X3 - 2*X4 - 163 = 0
2*X1 + X2 - 3*X3 - 2*X4 - 46 = 0
X1 - 14*X2 - 11*X3 + 25*X4 + 963 = 0
5*X1 - 4*X2 - 12*X3 + 6*X4 + 318 = 0
The answer is the value of X3, or 'No solution' / 'Multiple soluti... | 17 | {"equations": ["-2*X1 + 4*X3 + X4 - 12 = 0", "-4*X1 + 2*X2 + 9*X3 - 2*X4 - 163 = 0", "2*X1 + X2 - 3*X3 - 2*X4 - 46 = 0", "X1 - 14*X2 - 11*X3 + 25*X4 + 963 = 0", "5*X1 - 4*X2 - 12*X3 + 6*X4 + 318 = 0"], "query_variable": "X3", "full_solution_map": {"X1": 18, "X2": 21, "X3": 17, "X4": -20}, "case": "unique", "cot": "1. F... | 2 | instruct |
code_runnability | Predict whether this Python call runs successfully or raises an exception.
```python
def fn2(p3, p4):
return p3 if 3 > p3 else p3
def endpoint(arg1):
seq5 = [(arg1 if arg1 < arg1 else arg1) if arg1 > 1 and arg1 >= arg1 else arg1 * arg1, fn2(arg1, fn2(arg1, arg1)), arg1, arg1 if arg1 != arg1 and arg1 > arg1 els... | OK | {"code": "def fn2(p3, p4):\n return p3 if 3 > p3 else p3\n\ndef endpoint(arg1):\n seq5 = [(arg1 if arg1 < arg1 else arg1) if arg1 > 1 and arg1 >= arg1 else arg1 * arg1, fn2(arg1, fn2(arg1, arg1)), arg1, arg1 if arg1 != arg1 and arg1 > arg1 else arg1 * arg1, fn2(arg1, arg1) * -2]\n acc6 = fn2(arg1 if 1 != arg1 ... | 1 | instruct |
function_manipulation | Define $h(x)=\left(\left(\frac{d}{dx}\left(\left(\left(\frac{d}{dx}\left(\left(\left(x\right)-\left(2\left(x+2\right) + 5\left(x+2\right)^{2} + \left(x+2\right)^{3}\right)\right)-\left(\frac{4}{3}\left(x+2\right)\right)\right)\right)+\left(-\left(x+2\right) + \frac{5}{3}\left(x+2\right)^{2}\right)\right)\left(1 - 2\lef... | -16/3 | {"definitions": [], "expression": {"op": "sub", "args": [{"op": "mul", "args": [{"op": "diff", "args": [{"op": "mul", "args": [{"op": "add", "args": [{"op": "diff", "args": [{"op": "sub", "args": [{"op": "sub", "args": [{"op": "var"}, {"op": "poly", "coeffs": ["0", "2", "5", "1"], "center": "-2"}]}, {"op": "poly", "coe... | 6 | instruct |
planning | Initial true facts: clear(kestrel), fixed(delta), open(amber), open(birch), safe(delta). All other facts are false.
Actions (preconditions -> effects; !fact means false):
release(delta,indigo): fixed(indigo),open(birch),safe(delta),!clear(birch),!cool(coral),!warm(harbor) -> clear(birch),marked(jade)
align(linen,delta... | align(linen,delta)
release(delta,indigo)
prime(harbor,kestrel)
bind(jade,kestrel)
align(linen,fjord)
fasten(delta,harbor)
join(indigo,elm) | {"engine": "bounded-strips-v1", "horizon": 7, "style": "gray", "initial_true": ["clear(kestrel)", "fixed(delta)", "open(amber)", "open(birch)", "safe(delta)"], "actions": [{"call": "release(delta,indigo)", "pre_true": ["fixed(indigo)", "open(birch)", "safe(delta)"], "pre_false": ["clear(birch)", "cool(coral)", "warm(ha... | 4 | instruct |
table_statistics | Table:
group: G0; G: 0.79; R: 0.48; W: -0.21; D: 0.13; C: -1.7; V: 1.15
group: G1; G: 0.31; R: 2.39; W: 2.78; D: 1.48; C: -1.06; V: 0.25
group: G1; G: 0.58; R: -0.54; W: 3.21; D: 2.34; C: 1.83; V: 1.39
group: G1; G: 2.04; R: -1.1; W: 2.42; D: 1.54; C: 1.23; V: 1.27
group: G1; G: 0.63; R: -0.92; W: 3.5; D: 1.35; C: 0.5;... | W | {"table": "group: G0; G: 0.79; R: 0.48; W: -0.21; D: 0.13; C: -1.7; V: 1.15\ngroup: G1; G: 0.31; R: 2.39; W: 2.78; D: 1.48; C: -1.06; V: 0.25\ngroup: G1; G: 0.58; R: -0.54; W: 3.21; D: 2.34; C: 1.83; V: 1.39\ngroup: G1; G: 2.04; R: -1.1; W: 2.42; D: 1.54; C: 1.23; V: 1.27\ngroup: G1; G: 0.63; R: -0.92; W: 3.5; D: 1.35;... | 3 | instruct |
dynamic_programming | States: A B C
Observations: 2 1 2 2 1
Start: A=2 B=-3 C=-3
Transitions (rows=from, columns=A B C):
A: 2 -2 -2
B: -2 -3 1
C: 0 1 -3
Emissions (rows=state, columns=0..2):
A: -2 1 0
B: 2 -2 0
C: -3 0 -2
Score a state sequence by start + emissions + transitions. Find the maximum-score sequence; ties are lexicographic. The ... | A A A A A | {"labels": ["A", "B", "C"], "obs": [2, 1, 2, 2, 1], "start": [2, -3, -3], "trans": [[2, -2, -2], [-2, -3, 1], [0, 1, -3]], "emit": [[-2, 1, 0], [2, -2, 0], [-3, 0, -2]], "_time": 0.00022172927856445312, "_task": "dynamic_programming", "_level": 0, "_config": {"level": 0, "seed": null, "size": null, "n_states": 3, "n_sy... | 0 | instruct |
reference_tracking | Inventory:
- b1: black
- b2: black
- b3: white
- b4: green
- b5: red
Initial State:
- b1 is in x3
- b2 is in x2
- b3 is in x3
- b4 is in x3
- b5 is in x3
Moves:
- Relocate b3 from x3 to x4.
- Relocate b5 from x3 to x1.
- Relocate all balls from x1 to x2.
- Relocate b5 from x2 to x4.
- Transfer everything in x4 into x... | x2 | {"family": "track", "balls": ["b1", "b2", "b3", "b4", "b5"], "boxes": ["x1", "x2", "x3", "x4"], "colors": {"b1": "black", "b2": "black", "b3": "white", "b4": "green", "b5": "red"}, "initial_placement": {"b1": "x3", "b2": "x2", "b3": "x3", "b4": "x3", "b5": "x3"}, "moves": ["Relocate b3 from x3 to x4.", "Relocate b5 fro... | 3 | instruct |
string_transduction | String: quiet amber nova pixel winter vector
Operations:
- rotate left by 15
- sort ascending
- replace u with g
- replace n with c
- keep only t and o
- rotate left by 1
- sort descending
- dedupe adjacent repeats
Answer with the final string. | to | {"mode": "program", "source": "quiet amber nova pixel winter vector", "ops": ["rotate left by 15", "sort ascending", "replace u with g", "replace n with c", "keep only t and o", "rotate left by 1", "sort descending", "dedupe adjacent repeats"], "noop_rate": 0.0, "local_change_flags": [true, true, true, true, true, true... | 6 | instruct |
graph_pathfinding | Find the minimum-cost directed path from node 5 to node 7. Break ties lexicographically. Return space-separated nodes, or `None` if no path exists.
Graph:
Nodes [0, 1, 2, 3, 4, 5, 6, 7]. Directed Edges: 0->5(1), 0->6(6), 0->7(1), 1->2(4), 1->6(2), 1->7(3), 2->0(7), 2->1(7), 2->5(6), 2->6(7), 3->7(2), 4->3(6), 4->7(7),... | 5 7 | {"weighted": true, "mention_no_path": true, "mention_ties": true, "graph_description": "Nodes [0, 1, 2, 3, 4, 5, 6, 7]. Directed Edges: 0->5(1), 0->6(6), 0->7(1), 1->2(4), 1->6(2), 1->7(3), 2->0(7), 2->1(7), 2->5(6), 2->6(7), 3->7(2), 4->3(6), 4->7(7), 5->0(5), 5->1(1), 5->2(9), 5->6(6), 5->7(3), 6->1(1), 6->2(4), 6->5... | 1 | instruct |
metamath_entailment | Which premise set makes the conjecture follow using only the listed rules?
Exactly one of A and B is sufficient.
Rules instantiate only by renaming variables.
The answer is A or B.
Premise Set A:
1. P1(x, y)
2. P2(y, z)
3. ctx => P4(y, z)
Premise Set B:
1. P1(z, y)
2. P2(y, x)
3. ctx => P4(y, z)
Allowed Rules:
r1: P... | B | {"premise_sets": [["P1(x, y)", "P2(y, z)", "ctx => P4(y, z)"], ["P1(z, y)", "P2(y, x)", "ctx => P4(y, z)"]], "raw_premise_sets": [[["|-", "B", "=", "C"], ["|-", "C", "C_", "A"], ["|-", "(", "ph", "->", "C", "e.", "A", ")"]], [["|-", "A", "=", "C"], ["|-", "C", "C_", "B"], ["|-", "(", "ph", "->", "C", "e.", "A", ")"]]],... | 3 | instruct |
grid_navigation | Grid [0,10]x[0,10], N=+y, E=+x.
Initial Facts:
- F is right of G.
- F is above I.
- B is below G.
- G is above A.
- C starts at (6, 10).
- H is above E.
- B is left of C.
- D is in the same row as F.
- H is left of B.
- E is right of G.
- E starts at (5, 1).
- A is right of I.
- G is in the same column as H.
- I is lef... | (right, below) | {"answer_type": "relation", "query_a": "H", "query_b": "I", "grid": 10, "objects": ["A", "B", "C", "D", "E", "F", "G", "H", "I"], "facts": [{"k": "h", "a": "F", "b": "G", "r": "right"}, {"k": "v", "a": "F", "b": "I", "r": "above"}, {"k": "v", "a": "B", "b": "G", "r": "below"}, {"k": "v", "a": "G", "b": "A", "r": "above... | 6 | instruct |
multistep_abduction | Premise:
[0] farah is careful.
[1] alice is quiet.
[2] bruno is verified.
[3] alice contacts clara.
[4] alice is active.
[5] elena is alert.
[6] elena does not stand in the trusts relation to bruno.
[7] bruno does not stand in the helps relation to clara.
[8] alice is careful.
[9] farah is eligible.
[10] alice is appro... | 9 | {"premise": ["farah is careful.", "alice is quiet.", "bruno is verified.", "alice contacts clara.", "alice is active.", "elena is alert.", "elena does not stand in the trusts relation to bruno.", "bruno does not stand in the helps relation to clara.", "alice is careful.", "farah is eligible.", "alice is approved.", "al... | 5 | instruct |
math_word_problem | Tom has 23 fewer cookies than Nina. Nina has 11 more cookies than Leo. Nina has 46 cookies. How many cookies does Tom have? Answer with a number. | 23 | {"family": "relational", "unit": "cookies", "names": ["Leo", "Nina", "Tom"], "relations": [["fewer", "Tom", "Nina", 23, null], ["more", "Nina", "Leo", 11, null]], "given": "Nina", "asked": "Tom", "given_value": 46, "values": {"Leo": 35, "Nina": 46, "Tom": 23}, "base": 35, "query_distance": 1, "proof_core_size": 1, "dee... | 2 | instruct |
set_missing_element | Answer with the missing elements in the ordered span of ['2021-08-26', '2021-08-29', '2021-09-01', '2021-08-31', '2021-08-28', '2021-08-30', '2021-08-24', '2021-08-27', '2021-08-25'] as a Python set. | {} | {"element_list": ["2021-08-26", "2021-08-29", "2021-09-01", "2021-08-31", "2021-08-28", "2021-08-30", "2021-08-24", "2021-08-27", "2021-08-25"], "missing_count": 0, "_time": 0.00021338462829589844, "_task": "set_missing_element", "_level": 1, "_config": {"level": 1, "seed": null, "size": null, "domain_size": 300, "set_... | 1 | instruct |
shift_reduce_parsing | Rules:
R0: N0 -> d
R1: N1 -> a
R2: N2 -> N0 N0 N0
R3: N3 -> d
R4: N4 -> N2 N2
Input: d d d d d d
Shift tokens left to right. After every shift, repeatedly reduce the longest stack suffix matching a rule RHS; ties use the lowest rule number.
What is the stack after consuming 4 tokens? The answer is the stack symbols fro... | N2 N0 | {"rules": [["N0", ["d"]], ["N1", ["a"]], ["N2", ["N0", "N0", "N0"]], ["N3", ["d"]], ["N4", ["N2", "N2"]]], "tokens": ["d", "d", "d", "d", "d", "d"], "k": 4, "_time": 0.00020599365234375, "_task": "shift_reduce_parsing", "_level": 1, "_config": {"level": 1, "seed": null, "size": null, "n_rules": 5, "derivation_depth": 7... | 1 | instruct |
multistep_evidence_retrieval | Premise:
[0] farah is a parent of clara.
[1] clara is a parent of george.
[2] george is a parent of elena.
[3] elena is not an ancestor of george.
[4] david helps farah.
[5] clara is not trusted.
[6] elena helps bruno.
[7] elena is an ancestor of bruno.
[8] For all x, y, if x is a parent of y, then x is an ancestor of ... | 0 1 2 7 9 | {"premise": ["farah is a parent of clara.", "clara is a parent of george.", "george is a parent of elena.", "elena is not an ancestor of george.", "david helps farah.", "clara is not trusted.", "elena helps bruno.", "elena is an ancestor of bruno.", "For all x, y, if x is a parent of y, then x is an ancestor of y.", "W... | 4 | instruct |
function_manipulation | Let $f(x)=\frac{1}{3} + x - x^{2} + 2x^{3}$.
Define $h(x)=f\left(\int_{3}^{x}\left(\left(t_{1}\right)\left(1 + \left(t_{1}-3\right)\right)\right)\,dt_{1}\right)$.
Compute $h'(3)$.
The answer is a reduced rational number. | 3 | {"definitions": [{"name": "f", "kind": "explicit", "input_center": "0", "output_center": "1/3", "coeffs": ["1/3", "1", "-1", "2"]}], "expression": {"op": "call", "args": [{"op": "integrate", "args": [{"op": "mul", "args": [{"op": "var"}, {"op": "poly", "coeffs": ["1", "1"], "center": "3"}]}]}], "name": "f"}, "latex": "... | 2 | instruct |
combinatorics_formula | Write the counting expression. C(n,k) is unordered; P(n,k) is ordered.
Problem:
Line up 8 people so that Alice and Bob stand next to each other.
The answer must have the form:
X1X2X3!
where:
X1 := 8 | 7 | 2
X2 := - | *
X3 := 6 | 2 | 7
Answer with the complete expression. | 2*7! | {"family": "block_arrangement", "structural_depth": 1, "program_type": "Arrange", "program": {"objects": 8, "circular": false, "adjacent_pair": true}, "correct_expression": "2*7!", "correct_option_index": 2, "correct_option_label": "C", "correct_features": {"top_operator": "product", "ast_size": 4, "contains_combinatio... | 6 | instruct |
table_statistics | Table:
\begin{tabular}{llllll}
\hline
P & S & F & U & C & R \\
\hline
-3.78 & -5.06 & 1.15 & -1.81 & 2.24 & 2.67 \\
0.15 & 2.83 & -2.26 & 1.97 & 2.27 & -0.57 \\
-2.16 & -0.01 & -0.99 & 1.78 & -0.27 & -0.64 \\
-1.62 & -0.33 & -1.93 & 0.57 & -0.81 & -1.24 \\
-0.16 & -0.68 & -0.01 & ... | F | {"table": "\\begin{tabular}{llllll}\n\\hline\n P & S & F & U & C & R \\\\\n\\hline\n -3.78 & -5.06 & 1.15 & -1.81 & 2.24 & 2.67 \\\\\n 0.15 & 2.83 & -2.26 & 1.97 & 2.27 & -0.57 \\\\\n -2.16 & -0.01 & -0.99 & 1.78 & -0.27 & -0.64 \\\\\n -1.62 & -0.33 & -1.93 & 0.57 & -0.81 & -1.24 \\\\\n... | 3 | instruct |
regex_reasoning | A = (b)*(bba)(d)*ae?
B = ((aa)*c|abc*)|(baae+)b|ab*?
Find the shortest string that is accepted by exactly one of A or B (but not both).
The answer is the shortest such string. | a | {"qtype": "distinguishing", "regex_a": "(b)*(bba)(d)*ae?", "regex_b": "((aa)*c|abc*)|(baae+)b|ab*?", "_time": 0.10796785354614258, "_task": "regex_reasoning", "_level": 3, "_config": {"level": 3, "seed": null, "size": null, "max_depth": 7, "min_depth": 5, "n_alpha": 5, "gramforge_algorithm": "sequential"}, "_prompt_tok... | 3 | instruct |
metamath_core_select | Which option is sufficient to derive the conjecture?
Use only the listed premises and rules. No hidden background facts.
Rules may only rename variables, not substitute compound terms.
The answer is A, B, C, or D.
Premises:
1. ctx => P2(x, D1)
2. ctx => P2(y, D2)
3. ctx => P3(F1(y), C0)
Rule Catalog:
- r1: ctx => P2(... | B | {"premises": ["ctx => P2(x, D1)", "ctx => P2(y, D2)", "ctx => P3(F1(y), C0)"], "raw_premises": [["|-", "(", "ph", "->", "A", "e.", "RR", ")"], ["|-", "(", "ph", "->", "B", "e.", "CC", ")"], ["|-", "(", "ph", "->", "(", "Im", "`", "B", ")", "=", "0", ")"]], "conjecture": "ctx => P5(P4(C0, x), P4(y, F2(y, x)))", "raw_con... | 2 | instruct |
analogical_case_matching | Which case can be embedded into Query? A case matches when every fact maps to a Query fact under one-to-one entity and relation renaming, with an optional consistent direction reversal for each relation. Query may contain additional facts. Answer with its ID.
M0: d alpha a, f alpha d, f alpha e, a beta c, c gamma b
M1... | M0 | {"cases": [{"id": "M0", "context": [["alpha", "d", "a"], ["alpha", "f", "d"], ["alpha", "f", "e"], ["beta", "a", "c"], ["gamma", "c", "b"]], "consequence": ["alpha", "b", "a"]}, {"id": "M1", "context": [["alpha", "d", "a"], ["beta", "c", "b"], ["gamma", "d", "e"], ["gamma", "d", "f"], ["gamma", "e", "c"]], "consequence... | 2 | instruct |
multistep_nli | Premise:
david is a parent of bruno.
bruno is a parent of clara.
bruno trusts david.
Whenever x is a parent of y, x is an ancestor of y.
When one person is a parent of a second person and the second is an ancestor of a third person, the first is an ancestor of the third.
Hypothesis:
david is an ancestor of clara.
Is ... | Yes | {"premise": ["david is a parent of bruno.", "bruno is a parent of clara.", "bruno trusts david.", "Whenever x is a parent of y, x is an ancestor of y.", "When one person is a parent of a second person and the second is an ancestor of a third person, the first is an ancestor of the third."], "hypothesis": "david is an a... | 0 | instruct |
rule_switching | Maintain the register values while executing the program. The current mode determines each opcode's meaning. For an instruction on registers (a,b,c): rotate-left maps their values to (b,c,a); rotate-right to (c,a,b); swap-first-two to (b,a,c); swap-last-two to (a,c,b); and swap-outer to (c,b,a). Mode changes affect fol... | D | {"registers": ["r1", "r2", "r3", "r4", "r5"], "initial": {"r1": "A", "r2": "B", "r3": "C", "r4": "D", "r5": "E"}, "mappings": [{"X": "rotate-right", "Y": "swap-first-two", "Z": "swap-last-two"}, {"X": "swap-first-two", "Y": "swap-outer", "Z": "rotate-right"}], "program": [{"kind": "op", "operation": 0}, {"kind": "op", ... | 0 | instruct |
multistep_abduction | Premise:
[0] clara helps bruno.
[1] clara is verified.
[2] When a person helps a approved person, that person is careful.
[3] All things that are careful are not trusted.
Hypothesis:
clara is trusted.
Candidate Facts:
[0] bruno is active.
[1] alice is approved.
[2] bruno is verified.
[3] bruno is approved.
[4] bruno ... | 3 | {"premise": ["clara helps bruno.", "clara is verified.", "When a person helps a approved person, that person is careful.", "All things that are careful are not trusted."], "hypothesis": "clara is trusted.", "candidates": ["bruno is active.", "alice is approved.", "bruno is verified.", "bruno is approved.", "bruno is no... | 0 | instruct |
set_expression | A = {'2020-02-15', '2020-01-18', '2020-02-04', '2020-02-07', '2020-02-19', '2020-01-28', '2020-02-26', '2020-02-21', '2020-01-17', '2020-02-09', '2020-03-02', '2020-01-10', '2020-01-01'}
B = {'2020-03-10', '2020-02-04', '2020-02-11', '2020-02-19', '2020-02-08', '2020-01-10', '2020-02-07', '2020-02-13', '2020-03-01', '2... | {'2020-02-08', '2020-02-11', '2020-02-12', '2020-02-13', '2020-03-01', '2020-03-10'} | {"expr": "(B - A)", "list_mode": false, "B": ["2020-03-10", "2020-02-04", "2020-02-11", "2020-02-19", "2020-02-08", "2020-01-10", "2020-02-07", "2020-02-13", "2020-03-01", "2020-02-26", "2020-01-01", "2020-02-12", "2020-02-21"], "A": ["2020-02-15", "2020-01-18", "2020-02-04", "2020-02-07", "2020-02-19", "2020-01-28", "... | 2 | instruct |
string_transduction | String: acabebceba
Operations:
- reverse
- caesar shift by 26
- rotate left by 3
Answer with the final string. | cbebacaabe | {"mode": "program", "source": "acabebceba", "ops": ["reverse", "caesar shift by 26", "rotate left by 3"], "noop_rate": 0.3333333333333333, "local_change_flags": [true, false, true], "effective_flags": [true, false, true], "effective_op_count": 2, "dead_op_count": 1, "cancelled_pair_count": 0, "required_effective_ops": ... | 1 | instruct |
metamath_entailment | Which premise set makes the conjecture follow using only the listed rules?
Exactly one of A and B is sufficient.
Rules instantiate only by renaming variables.
The answer is A or B.
Premise Set A:
1. ctx => P2(F1(x, C2), D1)
2. ctx => P2(x, D2)
3. ctx => P3(C0, x)
4. ctx => P2(y, D3)
Premise Set B:
1. ctx => P2(F1(y, ... | A | {"premise_sets": [["ctx => P2(F1(x, C2), D1)", "ctx => P2(x, D2)", "ctx => P3(C0, x)", "ctx => P2(y, D3)"], ["ctx => P2(F1(y, C2), D1)", "ctx => P2(x, D2)", "ctx => P3(C0, x)", "ctx => P2(x, D3)"]], "raw_premise_sets": [[["|-", "(", "ph", "->", "(", "A", "^", "2", ")", "e.", "ZZ", ")"], ["|-", "(", "ph", "->", "A", "e.... | 3 | instruct |
controlled_code_execution | Predict the value returned by this Python call.
```python
def endpoint():
state = [4, -2, 0, 3]
alias0 = state
state = state[:]
state[3] += 4
alias0[2] += state[3]
state[2] += alias0[3]
alias1 = state
alias1[0] += -4
state[1] += alias1[0]
def f2(xs, d):
xs[3] += d
... | [0, 6, 3, 6] | {"code": "def endpoint():\n state = [4, -2, 0, 3]\n alias0 = state\n state = state[:]\n state[3] += 4\n alias0[2] += state[3]\n state[2] += alias0[3]\n alias1 = state\n alias1[0] += -4\n state[1] += alias1[0]\n def f2(xs, d):\n xs[3] += d\n return xs[3] - xs[1]\n state[1] ... | 2 | instruct |
coreference | Each lineup contains the same introduced people exactly once. A reordering lists the source positions from left to right. Each description occurrence is independent, and later statements may resolve earlier ones.
(1) a tall young quiet kind chef named Tom, a short young quiet kind chef named Mia, a tall old quiet kind... | Adam | {"sentences": "(1) a tall young quiet kind chef named Tom, a short young quiet kind chef named Mia, a tall old quiet kind chef named Nora, and a short old quiet kind chef named Adam formed a lineup in that order.\n(2) The lineup from sentence 1 was reordered using positions 1, 3, 4, 2, in that order.\n(3) The lineup fr... | 2 | instruct |
planning | Initial true facts: free(fjord), open(coral), open(fjord), ready(grove), warm(harbor), warm(jade). All other facts are false.
Actions (preconditions -> effects; !fact means false):
prime(coral,amber): charged(birch),marked(birch),marked(delta),warm(jade),!clear(linen),!free(amber),!warm(grove) -> !marked(delta),!open(... | drain(linen,coral)
guide(jade,fjord)
join(harbor,indigo)
align(birch,fjord)
carry(delta,kestrel)
fasten(elm,coral)
prime(coral,amber)
route(indigo,kestrel) | {"engine": "bounded-strips-v1", "horizon": 8, "style": "gray", "initial_true": ["free(fjord)", "open(coral)", "open(fjord)", "ready(grove)", "warm(harbor)", "warm(jade)"], "actions": [{"call": "prime(coral,amber)", "pre_true": ["charged(birch)", "marked(birch)", "marked(delta)", "warm(jade)"], "pre_false": ["clear(line... | 5 | 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: [7], 3: [6], 4: [4], 5: [5], 6: [2], 7: [3]}
Queries:
[(5, 4), (0, 1)] | 5 1 | {"graph_description": "Adjacency Dictionary (source to targets): {0: [1], 1: [0], 2: [7], 3: [6], 4: [4], 5: [5], 6: [2], 7: [3]}", "queries": [[5, 4], [0, 1]], "payload": {"graph": "Adjacency Dictionary (source to targets): {0: [1], 1: [0], 2: [7], 3: [6], 4: [4], 5: [5], 6: [2], 7: [3]}", "queries": "[(5, 4), (0, 1)]... | 2 | instruct |
logic_derivation | Premise:
0: alice is a parent of david.
1: david is a parent of elena.
2: elena is a parent of bruno.
3: elena is careful.
4: clara is adult.
5: Whenever x is a parent of y, x is an ancestor of y.
6: 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.
7: For all p, x, y, if p i... | 5: 2 => elena is an ancestor of bruno
6: 1 @0 => david is an ancestor of bruno
6: 0 @1 => alice is an ancestor of bruno | {"premise": ["alice is a parent of david.", "david is a parent of elena.", "elena is a parent of bruno.", "elena is careful.", "clara is adult.", "Whenever x is a parent of y, 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.", "For all p, x, y, if p... | 1 | instruct |
defeasible_nli | An `unless` condition must be shown to block its rule.
Facts:
Farah is trained and a bird.
Clara is trained, blocked, a bird, a penguin, careful, and abnormal.
Bruno is trusted.
David is not trained and not blocked.
George is approved.
Farah helps Clara.
Rules:
Trained people are trusted unless blocked.
Trusted peopl... | Maybe | {"premise": ["farah is trained.", "clara is trained.", "clara is blocked.", "farah is bird.", "clara is bird.", "clara is penguin.", "farah helps clara.", "clara is careful.", "clara is ab bird.", "bruno is trusted.", "david is not trained.", "george is approved.", "david is not blocked.", "For all x, if x is trained a... | 3 | instruct |
finite_automaton_execution | States:
states 0..10, start state 5, accepting states {1, 2, 3, 4, 5, 7, 8}
Alphabet:
{a, b, c}
Transitions:
state 0: on a -> {5}; on b -> {2}; on c -> {1, 6, 7}
state 1: on a -> {3, 10}; on b -> {8, 9}; on c -> {2, 4, 6}
state 2: on a -> {3, 6}; on b -> {2, 9}; on c -> {0, 8, 9}
state 3: on a -> {5}; on b -> {1, 4, ... | 8 | {"payload": {"states": "states 0..10, start state 5, accepting states {1, 2, 3, 4, 5, 7, 8}", "alphabet": "{a, b, c}", "transitions": "state 0: on a -> {5}; on b -> {2}; on c -> {1, 6, 7}\nstate 1: on a -> {3, 10}; on b -> {8, 9}; on c -> {2, 4, 6}\nstate 2: on a -> {3, 6}; on b -> {2, 9}; on c -> {0, 8, 9}\nstate 3: o... | 3 | 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 4 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). succ(t3,t4).\nedge(n0,n3). edge(n0,n4). edge(n1,n2). edge(n1,n8). edge(n1,n9). edge(n2,n8). edge(n2,n9). edge(n3,n4). edge(n3,n6). edge(n4,n6). edge(n4,n7). edge(n5,n6). edge(n5,n7).... | 3 | instruct |
graph_pathfinding | Find the shortest directed path from node 1 to node 11. Return space-separated nodes, or `None` if no path exists.
Graph:
Adjacency Dictionary (source to targets): {0: [], 1: [0], 2: [3, 5, 6, 8, 9, 11], 3: [5, 6, 11], 4: [3, 6, 11], 5: [2, 6, 7, 10, 11], 6: [4, 7, 8, 10], 7: [4, 6, 9, 10, 11], 8: [3, 4, 7, 11], 9: [5... | None | {"weighted": false, "mention_no_path": true, "mention_ties": false, "graph_description": "Adjacency Dictionary (source to targets): {0: [], 1: [0], 2: [3, 5, 6, 8, 9, 11], 3: [5, 6, 11], 4: [3, 6, 11], 5: [2, 6, 7, 10, 11], 6: [4, 7, 8, 10], 7: [4, 6, 9, 10, 11], 8: [3, 4, 7, 11], 9: [5, 11], 10: [2, 3, 6, 7, 9], 11: [... | 2 | instruct |
multistep_nli | Premise:
David is bravo tagged.
David is echo tagged.
David is foxtrot tagged.
David is alpha tagged.
Farah is alpha tagged.
Clara is omega tagged.
For all x, if x is bravo tagged and x is echo tagged, then x is gamma tagged.
If a person is gamma tagged and foxtrot tagged, then that person is charlie tagged.
Anyone who... | Yes | {"premise": ["David is bravo tagged.", "David is echo tagged.", "David is foxtrot tagged.", "David is alpha tagged.", "Farah is alpha tagged.", "Clara is omega tagged.", "For all x, if x is bravo tagged and x is echo tagged, then x is gamma tagged.", "If a person is gamma tagged and foxtrot tagged, then that person is ... | 4 | instruct |
equation_system | Solve the following system of equations for the variable 'X1'.
System:
4*X1 + 2*X2 - X3 - 3*X4 + 28 = 0
2*X1 + X2 - X4 + 4 = 0
-3*X1 - 2*X2 + 2*X3 + X4 + 20 = 0
-15*X1 - 9*X2 + 7*X3 + 8*X4 + 2 = 0
-22*X1 - 12*X2 + 5*X3 + 13*X4 - 64 = 10
The answer is the value of X1, or 'No solution' / 'Multiple solutions'. | No solution | {"equations": ["4*X1 + 2*X2 - X3 - 3*X4 + 28 = 0", "2*X1 + X2 - X4 + 4 = 0", "-3*X1 - 2*X2 + 2*X3 + X4 + 20 = 0", "-15*X1 - 9*X2 + 7*X3 + 8*X4 + 2 = 0", "-22*X1 - 12*X2 + 5*X3 + 13*X4 - 64 = 10"], "query_variable": "X1", "full_solution_map": null, "case": "inconsistent", "_time": 0.08357858657836914, "_task": "equation... | 2 | instruct |
graph_pathfinding | Find the shortest directed path from node 15 to node 10. Break ties lexicographically. Return space-separated nodes.
Graph:
Nodes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
Adjacency Matrix (row indicates source, column indicates target):
[0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 1... | 15 3 1 10 | {"weighted": false, "mention_no_path": false, "mention_ties": true, "graph_description": "Nodes: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]\nAdjacency Matrix (row indicates source, column indicates target):\n[0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0]\n[0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, ... | 3 | instruct |
multistep_evidence_retrieval | Premise:
[0] map is left of lamp.
[1] lamp is left of coin.
[2] coin is left of key.
[3] box is right of key.
[4] Every left of relation creates a right of relation in the reverse direction.
[5] For all x, y, if x is right of y, then y is left of x.
[6] Whenever x is not inside y, y does not contain x.
[7] If one perso... | 0 1 2 3 5 7 | {"premise": ["map is left of lamp.", "lamp is left of coin.", "coin is left of key.", "box is right of key.", "Every left of relation creates a right of relation in the reverse direction.", "For all x, y, if x is right of y, then y is left of x.", "Whenever x is not inside y, y does not contain x.", "If one person is l... | 1 | instruct |
arithmetics | Evaluate abs(((10.8 // 7 * -15 % 2.9 % 10 + 8 + 4 - -10 + 1.8))).
Use exact arithmetic.
The answer is a number. | 26.2 | {"expr": "abs(((10.8 // 7 * -15 % 2.9 % 10 + 8 + 4 - -10 + 1.8)))", "display_expr": "abs(((10.8 // 7 * -15 % 2.9 % 10 + 8 + 4 - -10 + 1.8)))", "digit_mode": "normal", "semantics": "exact", "semantic_cue": true, "out_decimals": 7, "height": 9, "cot": "10.8 // 7 = 1\n1 * -15 = -15\n-15 % 2.9 = 2.4\n2.4 % 10 = 2.4\n2.4 + ... | 4 | 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:
- add(0,X) -> X
- pow(X,0) -> 1
- mu... | add(b,a) | {"theory": "arith", "rules": "- add(0,X) -> X\n- pow(X,0) -> 1\n- mul(X,1) -> X\n- pow(X,1) -> X\n- add(mul(X,Y),mul(X,Z)) -> mul(X,add(Y,Z))\n- mul(1,X) -> X\n- add(X,0) -> X\n- sub(X,0) -> X\n- sub(X,X) -> 0", "term": "add(b,add(mul(0,1),add(mul(add(mul(1,a),0),1),0)))", "normal_form": "add(b,a)", "used": ["mul_one_r... | 3 | instruct |
metamath_entailment | Which premise set makes the conjecture follow using only the listed rules?
Exactly one of A and B is sufficient.
Rules instantiate only by renaming variables.
The answer is A or B.
Premise Set A:
1. P1(x, D1)
2. P2(x, F1(y, C1))
Premise Set B:
1. P1(x, D1)
2. P2(y, F1(x, C1))
Allowed Rules:
r1: P1(y, D1); P2(x, F1(y... | B | {"premise_sets": [["P1(x, D1)", "P2(x, F1(y, C1))"], ["P1(x, D1)", "P2(y, F1(x, C1))"]], "raw_premise_sets": [[["|-", "B", "e.", "NN"], ["|-", "B", "=", "(", "A", "+", "1", ")"]], [["|-", "B", "e.", "NN"], ["|-", "A", "=", "(", "B", "+", "1", ")"]]], "rules": ["r1", "r2", "r3"], "raw_rule_labels": ["jm2.27dlem4", "negi... | 1 | 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:
- r(x5, x7, x12) = r(x0, a, x9)
- q(x6, h(a, x1), x5) = q(x6, x3, x2)
- h(x4, p(... | Yes | {"answer": "Yes", "equations": ["r(x5, x7, x12) = r(x0, a, x9)", "q(x6, h(a, x1), x5) = q(x6, x3, x2)", "h(x4, p(a, c)) = h(x2, x8)", "x12 = x11", "h(x2, x2) = h(x0, x10)", "h(x11, x11) = h(x9, x13)", "h(a, x3) = h(a, h(a, x1))"], "candidate": "p(x11, c) = p(x13, c)", "num_equations": 7, "num_variables": 14, "num_bindi... | 2 | 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,n6). edge(n1,n4). edge(n1,n6). edge(n2,n5). edge(n3,n4). edge(n3,n6). edge(n4,n5).\nleaf(n5). leaf(n6). leaf(n7).\nvalue(n0,20). value(n1,60). value(n2,50). value(n3,70). va... | 1 | instruct |
most_probable_outcome | A box contains 6 silver balls and 6 gold balls.
Two balls are drawn without replacing the first ball.
Which statement is more likely?
A: both selected balls are silver.
B: both selected balls are gold.
The answer is exactly one of: A, B, equal. | equal | {"problog": "0.5::d1_x; 0.5::d1_y.\n0.454545454545::d2_x; 0.545454545455::d2_y :- d1_x.\n0.545454545455::d2_x; 0.454545454545::d2_y :- d1_y.\na :- d1_x, d2_x.\nb :- d1_y, d2_y.\nquery(a).\nquery(b).", "english": "A box contains 6 silver balls and 6 gold balls.\nTwo balls are drawn without replacing the first ball.\nWhi... | 0 | instruct |
regex_reasoning | A = (((ab*)))+ae?e+daa|(ae)??
B = (((ad)ae)?)+
Find the shortest string that is accepted by exactly one of A or B (but not both).
The answer is the shortest such string. | ae | {"qtype": "distinguishing", "regex_a": "(((ab*)))+ae?e+daa|(ae)??", "regex_b": "(((ad)ae)?)+", "_time": 0.06218361854553223, "_task": "regex_reasoning", "_level": 4, "_config": {"level": 4, "seed": null, "size": null, "max_depth": 8, "min_depth": 6, "n_alpha": 5, "gramforge_algorithm": "sequential"}, "_prompt_tokens": ... | 4 | instruct |
End of preview. Expand in Data Studio
Procedural Pile: Procedural reasoning data SFT (and RL)
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: Designing Broad Procedural Data for Completion-Supervised Reasoning Training},
author={Sileo, Damien and Lacombe, Valentin and Kachler, Dimitri},
journal={arXiv preprint arXiv:2608.05148},
year={2026}
}
- Downloads last month
- 1,418