task large_stringclasses 55
values | prompt large_stringlengths 37 9.17k | answer large_stringlengths 1 3.52k | metadata large_stringlengths 527 194k | level int64 0 6 | mode large_stringclasses 1
value |
|---|---|---|---|---|---|
inverse_math | Find all real solutions x of: exp(3/x) - 5*exp(2/x)/3 + 5*exp(1/x) - 25/3 = 0
The answer is the exact solutions separated by commas, or none.
Use plain notation, e.g. 3*x^2*exp(x) + log(x)/2. | 1/log(5/3) | {"mode": "equation", "lhs": "exp(3/x) - 5*exp(2/x)/3 + 5*exp(1/x) - 25/3", "rhs": "0", "solutions": ["1/log(5/3)"], "_time": 0.007920980453491211, "_task": "inverse_math", "_level": 2, "_config": {"level": 2, "seed": null, "size": 2.6}, "_prompt_tokens": 75, "_answer_tokens": 7, "_cot_tokens": 0, "_generator_name": "re... | 2 | instruct |
inverse_math | Find all eigenvalues of the matrix with rows [1, 6, 3, 0]; [0, 1, 0, 0]; [0, 6, 4, 0]; [-4, 6, 5, 5].
The answer is the eigenvalues in increasing order, repeated according to algebraic multiplicity, separated by commas.
Use plain notation, e.g. 3*x^2*exp(x) + log(x)/2. | 1, 1, 4, 5 | {"mode": "eigen", "matrix": "[1, 6, 3, 0]; [0, 1, 0, 0]; [0, 6, 4, 0]; [-4, 6, 5, 5]", "eigenvalues": [1, 1, 4, 5], "_time": 0.019023656845092773, "_task": "inverse_math", "_level": 5, "_config": {"level": 5, "seed": null, "size": 5.0}, "_prompt_tokens": 101, "_answer_tokens": 10, "_cot_tokens": 0, "_generator_name": "... | 5 | instruct |
combinatorics_formula | Write the counting expression. C(n,k) is unordered; P(n,k) is ordered.
Problem:
Order 7 distinct objects linearly; a specified pair must stay together.
The answer must have the form:
X1X2X3!
where:
X1 := 2 | 5 | 7
X2 := * | -
X3 := 6 | 2 | 7
Answer with the complete expression. | 2*6! | {"family": "block_arrangement", "structural_depth": 1, "program_type": "Arrange", "program": {"objects": 7, "circular": false, "adjacent_pair": true}, "correct_expression": "2*6!", "correct_option_index": 2, "correct_option_label": "C", "correct_features": {"top_operator": "product", "ast_size": 4, "contains_combinatio... | 0 | 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: b alpha a, d alpha a, f beta d, g beta b, a gamma e, g ... | M6 | {"cases": [{"id": "M0", "context": [["alpha", "b", "a"], ["alpha", "d", "a"], ["beta", "f", "d"], ["beta", "g", "b"], ["gamma", "a", "e"], ["gamma", "g", "e"], ["gamma", "h", "a"]], "consequence": ["gamma", "d", "b"]}, {"id": "M1", "context": [["alpha", "b", "a"], ["alpha", "f", "a"], ["beta", "c", "b"], ["beta", "e", ... | 6 | instruct |
arithmetics | Evaluate (1 - 10) + 1 / max(-15, 9) // 1 + -8.
The answer is a number. | -17 | {"expr": "(1 - 10) + 1 / max(-15, 9) // 1 + -8", "display_expr": "(1 - 10) + 1 / max(-15, 9) // 1 + -8", "digit_mode": "normal", "semantics": "exact", "semantic_cue": false, "out_decimals": 5, "height": 7, "cot": "1 - 10 = -9\nmax(-15, 9) = 9\n1 / 9 = 1/9\n1/9 // 1 = 0\n-9 + 0 = -9\n-9 + -8 = -17", "_time": 0.001743078... | 2 | 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(x, D1)
2. ctx => P3(C0, x)
3. ctx => P2(y, D2)
Premise Set B:
1. ctx => P2(x, D1)
2. ctx => P3(C0, y)
3. ctx ... | A | {"premise_sets": [["ctx => P2(x, D1)", "ctx => P3(C0, x)", "ctx => P2(y, D2)"], ["ctx => P2(x, D1)", "ctx => P3(C0, y)", "ctx => P2(x, D2)"]], "raw_premise_sets": [[["|-", "(", "ph", "->", "A", "e.", "RR", ")"], ["|-", "(", "ph", "->", "0", "<", "A", ")"], ["|-", "(", "ph", "->", "B", "e.", "NN0", ")"]], [["|-", "(", "... | 0 | instruct |
qualitative_causal_reasoning | Assume linear causal relations, independent noise, and no exact cancellations.
- X0 directly increases X12.
- X0 directly increases X16.
- X0 directly decreases X8.
- X0 directly increases X9.
- X10 directly increases X11.
- X10 directly increases X2.
- X10 directly increases X4.
- X12 directly increases X13.
- X13 di... | decrease | {"edges": [["X0", "X12", "+"], ["X0", "X16", "+"], ["X0", "X8", "-"], ["X0", "X9", "+"], ["X10", "X11", "+"], ["X10", "X2", "+"], ["X10", "X4", "+"], ["X12", "X13", "+"], ["X13", "X3", "-"], ["X15", "X4", "+"], ["X15", "X6", "+"], ["X16", "X12", "+"], ["X16", "X2", "-"], ["X2", "X11", "-"], ["X4", "X13", "+"], ["X4", "... | 2 | instruct |
grid_navigation | Grid [0,6]x[0,6], N=+y, E=+x.
Initial Facts:
- A is above D.
- B starts at (3, 6).
- C is above E.
- C is above A.
- B is above E.
- C is left of D.
- D starts at (5, 2).
- C is right of A.
- C is below B.
- C is right of E.
Steps:
1. D moves by (-1, 1).
2. C jumps to D's position offset by (-1, 1).
3. B moves by (-2,... | 4 | {"answer_type": "distance", "query_a": "B", "query_b": "C", "grid": 6, "objects": ["A", "B", "C", "D", "E"], "facts": [{"k": "v", "a": "A", "b": "D", "r": "above"}, {"k": "coord", "a": "B", "p": [3, 6]}, {"k": "v", "a": "C", "b": "E", "r": "above"}, {"k": "v", "a": "C", "b": "A", "r": "above"}, {"k": "v", "a": "B", "b"... | 2 | instruct |
table_qa | Execute this SQL query on the table named dataframe:
Table 1:
| qty | status |
|:------|:----------|
| 2 | paid |
| 3 | paid |
| 4 | pending |
| 5 | pending |
| 6 | pending |
| 7 | paid |
| 8 | cancelled |
| 9 | cancelled |
| 10 | cancelled |
| 11 | cance... | 11.0 | {"table": "| qty | status |\n|:------|:----------|\n| 2 | paid |\n| 3 | paid |\n| 4 | pending |\n| 5 | pending |\n| 6 | pending |\n| 7 | paid |\n| 8 | cancelled |\n| 9 | cancelled |\n| 10 | cancelled |\n| 11 | cancelled |\n| 12 | cancelled |\n| 13 | ... | 5 | instruct |
multistep_evidence_retrieval | Premise:
[0] For all x, y, if x is not inside y, then y does not contain x.
[1] For all x, y, z, if x is left of y and y is left of z, then x is left of z.
[2] From x is left of y, it follows that y is right of x.
[3] From x is right of y, it follows that y is left of x.
[4] When one person is inside a second person an... | 1 2 7 8 9 14 | {"premise": ["For all x, y, if x is not inside y, then y does not contain x.", "For all x, y, z, if x is left of y and y is left of z, then x is left of z.", "From x is left of y, it follows that y is right of x.", "From x is right of y, it follows that y is left of x.", "When one person is inside a second person and t... | 4 | instruct |
set_missing_element | Answer with the missing elements in the ordered span of ['adb', 'adc', 'acy', 'ade', 'acp', 'acq', 'ado', 'adj', 'aco', 'adm', 'acm', 'adh', 'acn', 'adg', 'acw', 'adl', 'act', 'acu', 'acr', 'adi', 'add', 'ada', 'acv', 'adk', 'acz', 'adn', 'acs', 'acl', 'acx'] as a Python set. | {'adf'} | {"element_list": ["adb", "adc", "acy", "ade", "acp", "acq", "ado", "adj", "aco", "adm", "acm", "adh", "acn", "adg", "acw", "adl", "act", "acu", "acr", "adi", "add", "ada", "acv", "adk", "acz", "adn", "acs", "acl", "acx"], "missing_count": 1, "_time": 0.00023317337036132812, "_task": "set_missing_element", "_level": 4, ... | 4 | instruct |
controlled_code_execution | Predict the value returned by this Python call.
```python
def endpoint():
state = [6, -5, 2]
def f0(xs, d):
xs[1] += d
return xs[1] - xs[2]
state[2] += f0(state, 4)
for v1 in [-3, 3, 5, -6]:
state[1] = 1 * state[1] + v1
state[0] += state[1]
alias2 = state
alias2[0... | [14, -2, 15] | {"code": "def endpoint():\n state = [6, -5, 2]\n def f0(xs, d):\n xs[1] += d\n return xs[1] - xs[2]\n state[2] += f0(state, 4)\n for v1 in [-3, 3, 5, -6]:\n state[1] = 1 * state[1] + v1\n state[0] += state[1]\n alias2 = state\n alias2[0] += 5\n state[2] += alias2[0]\n ... | 3 | 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: n1. 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'... | n6 | {"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,n1). edge(n0,n2). edge(n1,n3). edge(n1,n6). edge(n2,n5). edge(n3,n4). edge(n3,n5).\nleaf(n4). leaf(n5). leaf(n6).\nvalue(n0,100). value(n1,0). value(n2,100). value(n3,60). v... | 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:
\begin{tabular}{lllll}
\hline
event\_date ... | No | {"table_a": "\\begin{tabular}{lllll}\n\\hline\n event\\_date & amount & product & revenue & customer \\\\\n\\hline\n 2026-07-06 & 2448.02 & Can & 353.6 & Sean Phillips \\\\\n 2025-03-11 & 2390.16 & Natural & 944.47 & Alice Rios \\\\\n 2026-08-30 & 1174.43 & Part... | 0 | instruct |
constraint_satisfaction | Edges: v1-v3.
Adjacent vertices have different colors numbered 0..2.
Constraints:
1. v3 in {0, 1}
2. v2 = v3
3. v0 != v1
4. (v1 = 1) or (v1 = v3)
5. v0 != 2
Question: What color number is v2?
Answer with one name or integer. | 0 | {"model_mode": "graph", "family": "graph", "solve_mode": "query", "query_type": "scalar", "structure_mode": null, "query": "v2", "query_var": "v2", "clues": ["v3 in {0, 1}", "v2 = v3", "v0 != v1", "(v1 = 1) or (v1 = v3)", "v0 != 2"], "constraints": ["v3 in {0, 1}", "v2 = v3", "v0 != v1", "(v1 = 1) or (v1 = v3)", "v0 !=... | 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... | B | {"registers": ["r1", "r2", "r3", "r4", "r5"], "initial": {"r1": "A", "r2": "B", "r3": "C", "r4": "D", "r5": "E"}, "mappings": [{"X": "swap-first-two", "Y": "rotate-left", "Z": "swap-outer"}, {"X": "swap-outer", "Y": "rotate-right", "Z": "swap-first-two"}], "program": [{"kind": "op", "operation": 0}, {"kind": "op", "ope... | 0 | instruct |
inverse_math | Claim: f = 12*x^2 - 24*x*y - 96*x + 62*y^2 + 196*y + 951/4 satisfies f >= -17/4 for all real x, y.
Prove or refute it. If true, answer 'proof: ' followed by f - (-17/4) written as a sum of terms w*(polynomial)^2 and positive constants, each w positive. If false, answer 'counterexample: ' followed by values, e.g. 'count... | proof: 2*(-5*y - 5)^2 + 3*(2*x - 2*y - 8)^2 | {"mode": "claim", "f": "12*x^2 - 24*x*y - 96*x + 62*y^2 + 196*y + 951/4", "bound": "-17/4", "vars": ["x", "y"], "_time": 0.01018834114074707, "_task": "inverse_math", "_level": 1, "_config": {"level": 1, "seed": null, "size": 1.8}, "_prompt_tokens": 143, "_answer_tokens": 27, "_cot_tokens": 0, "_generator_name": "reaso... | 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: n3. 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(n3)).\ninit(step(t0)).\ninit(control(player)).\nsucc(t0,t1). succ(t1,t2). succ(t2,t3). succ(t3,t4).\nedge(n0,n4). edge(n0,n5). edge(n0,n9). edge(n0,n10). edge(n1,n3). edge(n1,n8). edge(n1,n10). edge(n1,n11). edge(n2,n6). edge(n2,n11). edge(n3,n6). edge(n3,n7). edge(n3,... | 5 | instruct |
most_probable_outcome | A container has 10 red items, 4 blue items, 8 green items, 8 gold items.
Draw 4 items in sequence.
After draw 1, replace the item before the next draw.
After draw 2, replace the item before the next draw.
After draw 3, do not replace the item.
We observe that the first item is not red.
Which statement is more likely?
A... | A | {"problog": "", "english": "A container has 10 red items, 4 blue items, 8 green items, 8 gold items.\nDraw 4 items in sequence.\nAfter draw 1, replace the item before the next draw.\nAfter draw 2, replace the item before the next draw.\nAfter draw 3, do not replace the item.\nWe observe that the first item is not red.\... | 3 | instruct |
multistep_nli | Premise:
map is left of book.
book is left of vase.
vase is left of key.
box is disjoint from vase.
key is inside box.
Whenever x is left of y, y is right of x.
For all x, y, if x is right of y, then y is left of x.
If one person is above another, then the second is below the first.
From x is below y, it follows that y... | Yes | {"premise": ["map is left of book.", "book is left of vase.", "vase is left of key.", "box is disjoint from vase.", "key is inside box.", "Whenever x is left of y, y is right of x.", "For all x, y, if x is right of y, then y is left of x.", "If one person is above another, then the second is below the first.", "From x ... | 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. ctx => P2(F1(x), F1(y))
2. ctx => P2(F2(x), F2(y))
3. ctx => P2(F3(x), F3(y))
4. ctx => P2(F4(x), F4(y))
Premise Set B:... | A | {"premise_sets": [["ctx => P2(F1(x), F1(y))", "ctx => P2(F2(x), F2(y))", "ctx => P2(F3(x), F3(y))", "ctx => P2(F4(x), F4(y))"], ["ctx => P2(F1(x), F1(y))", "ctx => P2(F2(x), F2(y))", "ctx => P2(F3(y), F3(x))", "ctx => P2(F4(x), F4(y))"]], "raw_premise_sets": [[["|-", "(", "ph", "->", "(", "Homf", "`", "A", ")", "=", "(... | 3 | instruct |
function_manipulation | Let $f(x)=\left(x-\frac{7}{3}\right) - \left(x-\frac{7}{3}\right)^{2}$.
Define $h(x)=f\left(\frac{d}{dx}\left(\left(x\right)\left(1 - \frac{2}{3}\left(x+2\right)\right)\right)\right)$.
Compute $h'(-2)$.
The answer is a reduced rational number. | -4/3 | {"definitions": [{"name": "f", "kind": "explicit", "input_center": "7/3", "output_center": "0", "coeffs": ["0", "1", "-1"]}], "expression": {"op": "call", "args": [{"op": "diff", "args": [{"op": "mul", "args": [{"op": "var"}, {"op": "poly", "coeffs": ["1", "-2/3"], "center": "-2"}]}]}], "name": "f"}, "latex": "f\\left(... | 2 | instruct |
code_runnability | Predict whether this Python call runs successfully or raises an exception.
```python
def endpoint(arg1):
seq5 = [fn2(fn2(arg1, -2), fn2(arg1, arg1)), arg1, fn2(arg1, arg1) - arg1, fn2(3, -1 // arg1), fn2(arg1, arg1) if arg1 != arg1 else fn2(arg1, -1)]
acc6 = arg1
ref11 = seq5
seq5 = list(seq5)
ref11... | ZeroDivisionError | {"code": "def endpoint(arg1):\n seq5 = [fn2(fn2(arg1, -2), fn2(arg1, arg1)), arg1, fn2(arg1, arg1) - arg1, fn2(3, -1 // arg1), fn2(arg1, arg1) if arg1 != arg1 else fn2(arg1, -1)]\n acc6 = arg1\n ref11 = seq5\n seq5 = list(seq5)\n ref11[4] += 1\n acc6 += ref11[4] - seq5[4]\n for i7 in range(4):\n ... | 1 | instruct |
code_analysis | Program:
```python
import random
status, stage, x = 'wait', 'done', 0
def step():
global status, stage, x
if x != 1:
status = {'wait': 'done', 'idle': 'wait', 'done': 'idle'}[status]
elif status != 'done':
x = random.choice([0, 2, 1])
match status:
case 'wait':
... | 2 | {"program": "import random\n\nstatus, stage, x = 'wait', 'done', 0\n\ndef step():\n global status, stage, x\n if x != 1:\n status = {'wait': 'done', 'idle': 'wait', 'done': 'idle'}[status]\n elif status != 'done':\n x = random.choice([0, 2, 1])\n match status:\n case 'wait':\n ... | 1 | instruct |
most_probable_outcome | A box contains 4 silver balls and 8 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. | B | {"problog": "0.333333333333::d1_x; 0.666666666667::d1_y.\n0.272727272727::d2_x; 0.727272727273::d2_y :- d1_x.\n0.363636363636::d2_x; 0.636363636364::d2_y :- d1_y.\na :- d1_x, d2_x.\nb :- d1_y, d2_y.\nquery(a).\nquery(b).", "english": "A box contains 4 silver balls and 8 gold balls.\nTwo balls are drawn without replacin... | 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,country,qty,job
"Feb 03, 2... | No | {"table_a": "event_date,amount,country,qty,job\n\"Feb 03, 2026\",\"1,536.18\",Andorra,661.00,Charity officer\n\"Aug 04, 2026\",\"1,282.82\",United States Virgin Islands,693.00,\"Producer, radio\"\n\"Oct 02, 2025\",\"2,337.57\",Ghana,345.00,\"Scientist, biomedical\"\n\"May 07, 2025\",219.66,Slovakia (Slovak Republic),58... | 2 | instruct |
constrained_continuation | Complete <HOLE> according to the grammar.
GRAMMAR:
B ::= 'mission'
A ::= 'stock' A
B ::= 'mission' A
S ::= A
A ::= A B
A ::= B
S ::= '<' S '>'
SENTENCE:
<HOLE> > >
Return only the missing 3 tokens. | < < mission | {"g": "B ::= 'mission'\nA ::= 'stock' A\nB ::= 'mission' A\nS ::= A\nA ::= A B\nA ::= B\nS ::= '<' S '>'", "start": "S", "k": 3, "prefix": [], "suffix": [">", ">"], "sentence": "<HOLE> > >", "n_candidates": 1, "n_reachable": 16, "finite_space_exhaustively_checked": true, "_time": 0.3889799118041992, "_task": "constrain... | 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. ctx => P2(x, D1)
2. ctx => P2(y, D2)
3. ctx => P2(x, D2)
4. ctx => P3(C0, x)
5. ctx => P4(y, x)
Premise Set B:
1. ctx =... | B | {"premise_sets": [["ctx => P2(x, D1)", "ctx => P2(y, D2)", "ctx => P2(x, D2)", "ctx => P3(C0, x)", "ctx => P4(y, x)"], ["ctx => P2(x, D1)", "ctx => P2(y, D2)", "ctx => P2(x, D2)", "ctx => P3(C0, x)", "ctx => P4(x, y)"]], "raw_premise_sets": [[["|-", "(", "ph", "->", "A", "e.", "NN0", ")"], ["|-", "(", "ph", "->", "B", ... | 1 | instruct |
combinatorics_formula | Which expression counts the outcomes? C(n,k) is unordered; P(n,k) is ordered.
Problem:
Choose exactly one item from disjoint groups of sizes 7 and 7.
Options:
A. 7*7
B. 7+7
C. 7+7-1
D. 2*7*7
Answer A-D. | B | {"family": "sum_rule", "structural_depth": 1, "program_type": "ChoiceRule", "program": {"kind": "sum", "first": 7, "second": 7}, "correct_expression": "7+7", "correct_option_index": 1, "correct_option_label": "B", "correct_features": {"top_operator": "sum", "ast_size": 3, "contains_combination": false, "contains_permut... | 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,country,customer,product
2... | Yes | {"table_a": "event_date,amount,country,customer,product\n2024-11-19,940.0,Saint Martin,Sarah Smith,Green\n2025-02-01,1900.1,Angola,Daniel Ward,Poor\n2025-02-10,1872.65,Niger,Amy Espinoza,Color\n2026-06-15,2309.28,Jersey,Kelly Kelly,Special\n2026-03-24,1808.04,Singapore,Lindsay Young DDS,Them\n2025-03-20,771.79,Turks an... | 1 | instruct |
math_word_problem | Iris has 21 fewer books than Zara. Leo has 3 times as many books as Kof. Kof has 2 times as many books as Zara. Zara has 22 books. How many books does Kof have? Answer with a number. | 44 | {"family": "relational", "unit": "books", "names": ["Zara", "Kof", "Iris", "Leo"], "relations": [["fewer", "Iris", "Zara", 21, null], ["times", "Leo", "Kof", 3, null], ["times", "Kof", "Zara", 2, null]], "given": "Zara", "asked": "Kof", "given_value": 22, "values": {"Zara": 22, "Kof": 44, "Iris": 1, "Leo": 132}, "base"... | 1 | instruct |
function_manipulation | Define $h(x)=\int_{-2}^{x}\left(\left(t_{1}\right)\left(1 - \left(t_{1}+2\right)\right)\right)\,dt_{1}$.
Simplify $h(x)$ to an expanded polynomial in $x$.
The answer is an expanded polynomial with reduced rational coefficients. | -1/3*x^3 - 1/2*x^2 - 2/3 | {"definitions": [], "expression": {"op": "integrate", "args": [{"op": "mul", "args": [{"op": "var"}, {"op": "poly", "coeffs": ["1", "-1"], "center": "-2"}]}]}, "latex": "\\int_{-2}^{x}\\left(\\left(t_{1}\\right)\\left(1 - \\left(t_{1}+2\\right)\\right)\\right)\\,dt_{1}", "root_center": "-2", "mode": "polynomial", "orde... | 0 | 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: (((\_1.(((\_4.((\_6.(\_3._6)) _4)) _1) b)) (b ((\_2.(d ((\_7.(a ((\_0.(_7 b)) b))) (\_5.c)))) a))) b)
The answer is the β-normal form (compared up to... | ((b (d (a c))) b) | {"term": "(((\\_1.(((\\_4.((\\_6.(\\_3._6)) _4)) _1) b)) (b ((\\_2.(d ((\\_7.(a ((\\_0.(_7 b)) b))) (\\_5.c)))) a))) b)", "normal_form": "((b (d (a c))) b)", "beta_steps": 8, "has_shadowing": false, "shadowing": 0, "capture_risk": 0, "alpha_renaming": 0, "syntactic_alpha_renaming": 0, "skeleton": ["a", ["a", ["l", ["a"... | 2 | instruct |
multistep_evidence_retrieval | Premise:
[0] From x is a parent of y and y is an ancestor of z, it follows that x is an ancestor of z.
[1] Whenever x is a parent of y, x is an ancestor of y.
[2] alice is an aunt or uncle of bruno.
[3] bruno is a parent of clara.
[4] clara is a parent of alice.
Hypothesis:
bruno is not an ancestor of alice.
Which pr... | 0 1 3 4 | {"premise": ["From x is a parent of y and y is an ancestor of z, it follows that x is an ancestor of z.", "Whenever x is a parent of y, x is an ancestor of y.", "alice is an aunt or uncle of bruno.", "bruno is a parent of clara.", "clara is a parent of alice."], "hypothesis": "bruno is not an ancestor of alice.", "labe... | 0 | instruct |
code_analysis | Program:
```python
mode, x = 'busy', 1
def step():
global mode, x
mode, x = 'closed', (x + 1) % 2
match x:
case 0:
mode = 'open'
case 1:
x = max(x - 1, 0)
case _:
x = min(x + 1, 1)
```
Start from the assignments above; each transition calls `ste... | [('closed', 0)] | {"program": "mode, x = 'busy', 1\n\ndef step():\n global mode, x\n mode, x = 'closed', (x + 1) % 2\n match x:\n case 0:\n mode = 'open'\n case 1:\n x = max(x - 1, 0)\n case _:\n x = min(x + 1, 1)\n", "predicates": "p0 := mode == 'open'\np1 := mode == 'busy'... | 1 | instruct |
logic_qa | Premise:
Alice is delta-related to Elena.
Elena is gamma-linked to Bruno.
David is foxtrot tagged.
Clara is foxtrot tagged.
Elena is delta-related to Alice.
From x is delta-related to y and y is gamma-linked to z, it follows that x is alpha-linked to z.
From x is alpha-linked to z, it follows that x is foxtrot tagged.
... | 3 | {"premise": ["Alice is delta-related to Elena.", "Elena is gamma-linked to Bruno.", "David is foxtrot tagged.", "Clara is foxtrot tagged.", "Elena is delta-related to Alice.", "From x is delta-related to y and y is gamma-linked to z, it follows that x is alpha-linked to z.", "From x is alpha-linked to z, it follows tha... | 1 | instruct |
belief_tracking | Initially, everyone knows that the coin is in the bowl, the ticket is in the tray, and the map is in the vase.
Story: Frank moves the ticket to the chest. No one else sees the move. Alice moves the ticket to the chest. Alice and Frank watch together and can see one another. Bob moves the coin to the tray. Unknown to t... | bowl | {"agents": ["Bob", "Grace", "Eve", "Alice", "Dave", "Frank"], "objects": ["coin", "ticket", "map"], "containers": ["case", "bin", "bowl", "chest", "vase", "tray"], "init": {"loc": {"coin": "bowl", "ticket": "tray", "map": "vase"}}, "specs": [{"kind": "move", "actor": "Frank", "target": null, "policy": null, "report_typ... | 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:
Directed Edges: 0->0, 1->5, 2->8, 3->1, 4->4, 5->3, 6->7, 7->6, 8->2
Queries:
[(2, 4), (4, 1), (5, 3)] | 2 4 5 | {"graph_description": "Directed Edges: 0->0, 1->5, 2->8, 3->1, 4->4, 5->3, 6->7, 7->6, 8->2", "queries": [[2, 4], [4, 1], [5, 3]], "payload": {"graph": "Directed Edges: 0->0, 1->5, 2->8, 3->1, 4->4, 5->3, 6->7, 7->6, 8->2", "queries": "[(2, 4), (4, 1), (5, 3)]"}, "nodes": [0, 1, 2, 3, 4, 5, 6, 7, 8], "edges": [[0, 0], ... | 3 | instruct |
planar_geometry_relations | Given points: A=(3, 9); C=(-9, 1); D=(-8, -9); F=(-361/66, -37/22); I=(4, 8); L=(4, 17); M=(16, 16); N=(-21, 2); S=(-6, -3/2); T=(3, 0); U=(9, -5); V=(-64/11, -3/2); Y=(5, -2).
Question: Are points S, V, and F collinear?
Answer is either Yes or No. | No | {"points": {"A": "(3, 9)", "C": "(-9, 1)", "D": "(-8, -9)", "F": "(-361/66, -37/22)", "I": "(4, 8)", "L": "(4, 17)", "M": "(16, 16)", "N": "(-21, 2)", "S": "(-6, -3/2)", "T": "(3, 0)", "U": "(9, -5)", "V": "(-64/11, -3/2)", "Y": "(5, -2)"}, "definitions": [], "query": "Are points S, V, and F collinear?", "instruction":... | 3 | instruct |
planning | Initial true facts: active(fjord), closed(harbor), dry(delta), fixed(amber), free(amber), free(fjord). All other facts are false.
Actions (preconditions -> effects; !fact means false):
release(delta,harbor): active(fjord),dry(delta),open(fjord),!warm(jade) -> dry(fjord),!active(fjord),!free(fjord),!open(fjord)
lift(co... | prime(coral,grove)
carry(amber,linen)
join(indigo,kestrel)
prime(harbor,indigo)
shift(delta,harbor)
drain(indigo,elm)
prime(linen,coral) | {"engine": "bounded-strips-v1", "horizon": 7, "style": "onehot", "initial_true": ["active(fjord)", "closed(harbor)", "dry(delta)", "fixed(amber)", "free(amber)", "free(fjord)"], "actions": [{"call": "release(delta,harbor)", "pre_true": ["active(fjord)", "dry(delta)", "open(fjord)"], "pre_false": ["warm(jade)"], "add": ... | 4 | instruct |
logic_derivation | Premise:
0: coin is above lamp.
1: lamp is above key.
2: box is inside key.
3: For all x, y, if x is not left of y, then y is not right of x.
4: From x is above y, it follows that y is below x.
5: For all x, y, z, if x is above y and y is above z, then x is above z.
6: For all x, y, if x is disjoint from y, then y is d... | 5: 0 1 => coin is above key
4: @0 => key is below coin | {"premise": ["coin is above lamp.", "lamp is above key.", "box is inside key.", "For all x, y, if x is not left of y, then y is not right of x.", "From x is above y, it follows that y is below x.", "For all x, y, z, if x is above y and y is above z, then x is above z.", "For all x, y, if x is disjoint from y, then y is... | 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: n3. 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(n3)).\ninit(step(t0)).\ninit(control(player)).\nsucc(t0,t1). succ(t1,t2). succ(t2,t3).\nedge(n0,n4). edge(n0,n5). edge(n1,n5). edge(n1,n7). edge(n2,n4). edge(n2,n6). edge(n3,n5). edge(n3,n7). edge(n4,n5). edge(n4,n6).\nleaf(n5). leaf(n6). leaf(n7).\nvalue(n0,20). value... | 1 | instruct |
reference_tracking | Inventory:
- b1: blue
- b2: white
- b3: blue
- b4: white
- b5: blue
Initial State:
- b1 is in x1
- b2 is in x2
- b3 is in x1
- b4 is in x3
- b5 is in x2
Moves:
- Transfer b1 from x1 into x3.
- Move b3 from x1 to x3.
- Transfer b5 from x2 into x1.
- Transfer b1 from x3 into x2.
- Transfer b4 from x3 into x1.
Where is ... | x2 | {"family": "track", "balls": ["b1", "b2", "b3", "b4", "b5"], "boxes": ["x1", "x2", "x3"], "colors": {"b1": "blue", "b2": "white", "b3": "blue", "b4": "white", "b5": "blue"}, "initial_placement": {"b1": "x1", "b2": "x2", "b3": "x1", "b4": "x3", "b5": "x2"}, "moves": ["Transfer b1 from x1 into x3.", "Move b3 from x1 to x... | 1 | instruct |
attribute_grammar | A parse tree is evaluated with an attribute grammar over string values. Two attributes are inherited (passed down): ctx, an integer that is 0 at the root, and env, a mapping from variable names to values that is empty at the root. One attribute is synthesized (passed up): the node's value. Rules:
- S('c'): a leaf whose... | aaaa | {"mode": "string", "tree": "env(2, env(-1, [Q]cat(S('a'), S('a'))))", "marked": true, "_time": 0.0004944801330566406, "_task": "attribute_grammar", "_level": 1, "_config": {"level": 1, "seed": null, "size": null, "depth": 4, "min_nodes": 5, "max_nodes": 10}, "_prompt_tokens": 262, "_answer_tokens": 1, "_cot_tokens": 0,... | 1 | instruct |
dynamic_programming | States: A B C D
Observations: 2 1 0 1 2 3 2 2 0 0
Start: A=-3 B=0 C=1 D=1
Transitions (rows=from, columns=A B C D):
A: -1 -1 -4 0
B: 2 4 -1 3
C: -2 2 3 3
D: 1 3 -4 2
Emissions (rows=state, columns=0..3):
A: 4 -4 -3 2
B: 3 -3 -1 -4
C: 0 -4 -3 3
D: 2 0 -1 -3
Score a state sequence by start + emissions + transitions. Find... | B D B D B B B B B B | {"labels": ["A", "B", "C", "D"], "obs": [2, 1, 0, 1, 2, 3, 2, 2, 0, 0], "start": [-3, 0, 1, 1], "trans": [[-1, -1, -4, 0], [2, 4, -1, 3], [-2, 2, 3, 3], [1, 3, -4, 2]], "emit": [[4, -4, -3, 2], [3, -3, -1, -4], [0, -4, -3, 3], [2, 0, -1, -3]], "_time": 0.0003426074981689453, "_task": "dynamic_programming", "_level": 4,... | 4 | 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... | F | {"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-left", "Z": "swap-outer"}, {"X": "rotate-right", "Y": "swap-outer", "Z": "swap-first-two"}, {"X": "swap-outer", "Y": "rotate-right", "Z": "s... | 3 | instruct |
function_manipulation | Let $f(x)=x - 2x^{2}$.
Define $h(x)=\left(f\left(\left(x\right)\left(1 - \frac{1}{3}x\right)\right)\right)\left(1 + x\right)$.
Compute $h^{(2)}(0)$.
The answer is a reduced rational number. | -8/3 | {"definitions": [{"name": "f", "kind": "explicit", "input_center": "0", "output_center": "0", "coeffs": ["0", "1", "-2"]}], "expression": {"op": "mul", "args": [{"op": "call", "args": [{"op": "mul", "args": [{"op": "var"}, {"op": "poly", "coeffs": ["1", "-1/3"], "center": "0"}]}], "name": "f"}, {"op": "poly", "coeffs":... | 1 | instruct |
set_expression | B = {'useful word', 'junior guest', 'basic term', 'smart heart', 'such classroom', 'common contest', 'numerous army', 'creative application', 'inner bedroom', 'open dog', 'gross attention', 'sure field', 'free day', 'mobile mother'}
Evaluate (B | B). | {'basic term', 'common contest', 'creative application', 'free day', 'gross attention', 'inner bedroom', 'junior guest', 'mobile mother', 'numerous army', 'open dog', 'smart heart', 'such classroom', 'sure field', 'useful word'} | {"expr": "(B | B)", "list_mode": false, "B": ["useful word", "junior guest", "basic term", "smart heart", "such classroom", "common contest", "numerous army", "creative application", "inner bedroom", "open dog", "gross attention", "sure field", "free day", "mobile mother"], "_time": 0.0004363059997558594, "_task": "set... | 2 | instruct |
inverse_math | The sequence a satisfies a(n+3) = 12*(-4)^n - 4*a(n) - 8*a(n+1) - 5*a(n+2) for n >= 0, with a(0) = 1/2, a(1) = 4, a(2) = -21.
Give a closed form for a(n). The answer is an expression in n.
Use plain notation, e.g. 3*x^2*exp(x) + log(x)/2. | (-1)^n - (-2)^n*n - (-2)^(n - 1) - (-4)^n | {"mode": "recurrence", "order": 3, "rhs": "12*(-4)^n - 4*a(n) - 8*a(n+1) - 5*a(n+2)", "init": ["1/2", "4", "-21"], "values": ["1/2", "4", "-21", "83", "-311", "1167", "-4447", "17215", "-67455", "266495", "-1058303", "4215807"], "_time": 0.053501129150390625, "_task": "inverse_math", "_level": 1, "_config": {"level": 1... | 1 | instruct |
constrained_continuation | Complete <HOLE> according to the grammar.
GRAMMAR:
B ::= '[' B ']'
E ::= 'too'
S ::= A
C ::= '<' C '>'
B ::= C
C ::= D
E ::= 'voice'
A ::= B
D ::= E
SENTENCE:
< <HOLE> voice > > > >
Return only the missing 3 tokens. | < < < | {"g": "B ::= '[' B ']'\nE ::= 'too'\nS ::= A\nC ::= '<' C '>'\nB ::= C\nC ::= D\nE ::= 'voice'\nA ::= B\nD ::= E", "start": "S", "k": 3, "prefix": ["<"], "suffix": ["voice", ">", ">", ">", ">"], "sentence": "< <HOLE> voice > > > >", "n_candidates": 1, "n_reachable": 5, "finite_space_exhaustively_checked": true, "_time"... | 2 | instruct |
defeasible_nli | An `unless` condition must be shown to block its rule.
Facts:
Farah is trained, a bird, approved, and not abnormal.
Alice is trained, flagged, a bird, a penguin, careful, and not blocked.
Clara is not abnormal and careful.
George is blocked.
Bruno is careful.
Elena is trained.
Farah helps Alice.
Rules:
Trained people... | No | {"premise": ["farah is trained.", "alice is trained.", "alice is flagged.", "farah is bird.", "alice is bird.", "alice is penguin.", "farah helps alice.", "alice is careful.", "clara is not ab bird.", "george is blocked.", "bruno is careful.", "farah is approved.", "clara is careful.", "elena is trained.", "alice is no... | 6 | 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, or None.
M0: c alpha e, a beta d, a gamma d, c gamma e
M1: ... | None | {"cases": [{"id": "M0", "context": [["alpha", "c", "e"], ["beta", "a", "d"], ["gamma", "a", "d"], ["gamma", "c", "e"]], "consequence": ["gamma", "c", "a"]}, {"id": "M1", "context": [["alpha", "c", "b"], ["alpha", "d", "e"], ["alpha", "e", "b"], ["beta", "b", "d"]], "consequence": ["alpha", "b", "e"]}, {"id": "M2", "con... | 0 | instruct |
table_statistics | Table:
N,P,L,C,B,X,A
-2.3,-2.72,-1.1,-0.22,-0.35,0.08,-1.52
1.38,0.9,0.32,1.58,0.67,1.51,0.37
-2.81,-3.19,-1.24,-1.57,0.69,-0.17,-2.12
1.17,0.76,0.28,0.7,1.81,1.63,1.27
0.31,1.17,0.33,-0.74,-0.81,0.66,2.16
2.33,0.27,-0.08,1.95,0.32,2.53,-0.16
1.42,1.35,0.74,0.36,0.85,0.33,-1.22
0.68,1.26,0.37,0.15,-0.07,-1.39,0.49
3.88... | L | {"table": "N,P,L,C,B,X,A\n-2.3,-2.72,-1.1,-0.22,-0.35,0.08,-1.52\n1.38,0.9,0.32,1.58,0.67,1.51,0.37\n-2.81,-3.19,-1.24,-1.57,0.69,-0.17,-2.12\n1.17,0.76,0.28,0.7,1.81,1.63,1.27\n0.31,1.17,0.33,-0.74,-0.81,0.66,2.16\n2.33,0.27,-0.08,1.95,0.32,2.53,-0.16\n1.42,1.35,0.74,0.36,0.85,0.33,-1.22\n0.68,1.26,0.37,0.15,-0.07,-1.... | 5 | 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(x, D1)
2. ctx => P2(F1(y, C2), D2)
3. ctx => P2(y, D3)
4. ctx => P2(y, D4)
Premise Set B:
1. ctx => P2(y, D1)... | A | {"premise_sets": [["ctx => P2(x, D1)", "ctx => P2(F1(y, C2), D2)", "ctx => P2(y, D3)", "ctx => P2(y, D4)"], ["ctx => P2(y, D1)", "ctx => P2(F1(x, C2), D2)", "ctx => P2(y, D3)", "ctx => P2(y, D4)"]], "raw_premise_sets": [[["|-", "(", "ph", "->", "A", "e.", "NN0", ")"], ["|-", "(", "ph", "->", "(", "B", "^", "2", ")", "e... | 2 | 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. P1(y, D2)
3. P2(z, F1(x, y))
Premise Set B:
1. P1(x, D1)
2. P1(y, D2)
3. P2(y, F1(x, z))
Allowed Rules:
r... | A | {"premise_sets": [["P1(x, D1)", "P1(y, D2)", "P2(z, F1(x, y))"], ["P1(x, D1)", "P1(y, D2)", "P2(y, F1(x, z))"]], "raw_premise_sets": [[["|-", "B", "e.", "NN0"], ["|-", "C", "e.", "RR"], ["|-", "A", "=", "(", "B", "+", "C", ")"]], [["|-", "B", "e.", "NN0"], ["|-", "C", "e.", "RR"], ["|-", "C", "=", "(", "B", "+", "A", "... | 5 | instruct |
regex_reasoning | A = a*|ad*(ad)ad(ba)+?ba(((c)aa|ad)*)
B = a*|ad*adad(ba)+ba(ad|ca{2})*
Do A and B accept exactly the same set of strings?
The answer is Yes or No. | Yes | {"qtype": "equivalence", "regex_a": "a*|ad*(ad)ad(ba)+?ba(((c)aa|ad)*)", "regex_b": "a*|ad*adad(ba)+ba(ad|ca{2})*", "_time": 1.0327932834625244, "_task": "regex_reasoning", "_level": 4, "_config": {"level": 4, "seed": null, "size": null, "max_depth": 8, "min_depth": 6, "n_alpha": 5, "gramforge_algorithm": "sequential"}... | 4 | instruct |
most_probable_outcome | A tray contains 2 silver tiles and 8 gold tiles.
Two tiles are selected with the first tile replaced before the second selection.
Which statement is more likely?
A: the selected tiles have the same color.
B: the selected tiles have different colors.
The answer is exactly one of: A, B, equal. | A | {"problog": "0.2::d1_x; 0.8::d1_y.\n0.2::d2_x; 0.8::d2_y.\na :- d1_x, d2_x.\na :- d1_y, d2_y.\nb :- d1_x, d2_y.\nb :- d1_y, d2_x.\nquery(a).\nquery(b).", "english": "A tray contains 2 silver tiles and 8 gold tiles.\nTwo tiles are selected with the first tile replaced before the second selection.\nWhich statement is mor... | 2 | instruct |
grid_navigation | Grid [0,8]x[0,8], N=+y, E=+x.
Initial Facts:
- A is right of B.
- F is below E.
- E is below C.
- B starts at (0, 7).
- D is below G.
- D is right of B.
- C is right of B.
- G is below C.
- G starts at (7, 7).
- G is right of B.
- G is above A.
- G is above E.
Steps:
1. E moves by (1, 0).
2. F and B swap positions.
3.... | (5, 7) | {"answer_type": "coord", "query_a": "A", "query_b": null, "grid": 8, "objects": ["A", "B", "C", "D", "E", "F", "G"], "facts": [{"k": "h", "a": "A", "b": "B", "r": "right"}, {"k": "v", "a": "F", "b": "E", "r": "below"}, {"k": "v", "a": "E", "b": "C", "r": "below"}, {"k": "coord", "a": "B", "p": [0, 7]}, {"k": "v", "a": ... | 4 | instruct |
table_statistics | Table:
| M | D | K | W |
|:------|:------|:------|:------|
| -2.11 | -0.17 | 1.07 | 0.08 |
| 2.08 | 0.33 | -1.11 | -0.1 |
| 0.53 | 0.5 | -0.37 | 0.59 |
| 0.13 | 0.71 | -0.4 | -0.12 |
| -1.62 | -1.27 | 1.82 | -1.55 |
| -2.17 | 0.56 | -1.0 | -1.78 |
| -3.21 | 0.04 | -0.26 | -1.16 |
| -6.08... | K | {"table": "| M | D | K | W |\n|:------|:------|:------|:------|\n| -2.11 | -0.17 | 1.07 | 0.08 |\n| 2.08 | 0.33 | -1.11 | -0.1 |\n| 0.53 | 0.5 | -0.37 | 0.59 |\n| 0.13 | 0.71 | -0.4 | -0.12 |\n| -1.62 | -1.27 | 1.82 | -1.55 |\n| -2.17 | 0.56 | -1.0 | -1.78 |\n| -3.21 | 0.04 | -0.26 | -1.... | 0 | instruct |
defeasible_nli | An `unless` condition must be shown to block its rule.
Facts:
Farah is alpha-tagged and foxtrot-tagged.
George is alpha-tagged, delta-tagged, foxtrot-tagged, gamma-tagged, and lambda-tagged.
Elena is bravo-tagged and foxtrot-tagged.
Bruno is kappa-tagged and echo-tagged.
Clara is echo-tagged.
Farah is alpha-linked to ... | Yes | {"premise": ["Farah is alpha tagged.", "George is alpha tagged.", "George is delta tagged.", "Farah is foxtrot tagged.", "George is foxtrot tagged.", "George is gamma tagged.", "Farah is alpha-linked to George.", "George is lambda tagged.", "Elena is bravo tagged.", "Bruno is kappa tagged.", "David is alpha-linked to E... | 3 | 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: yellow
- b2: red
- b3: green
- b4: black
Initial State:
- b1 is in x2
-... | b3 | {"family": "logical_winograd", "balls": ["b1", "b2", "b3", "b4"], "boxes": ["x1", "x2", "x3"], "colors": {"b1": "yellow", "b2": "red", "b3": "green", "b4": "black"}, "initial_placement": {"b1": "x2", "b2": "x3", "b3": "x3", "b4": "x1"}, "moves": ["Swap the balls in x1 and x2.", "Move b4 from x2 to x1.", "Relocate all b... | 0 | instruct |
code_analysis | Program:
```python
import random
index, status = 1, 'done'
def step():
global index, status
match index:
case 1:
index = max(index - 1, 0)
case 0:
status = random.choice(['done', 'fail', 'wait', 'idle'])
case _:
index = random.choice([1, 0])
```
St... | [(1, 'done'), (0, 'done'), (0, 'fail')] | {"program": "import random\n\nindex, status = 1, 'done'\n\ndef step():\n global index, status\n match index:\n case 1:\n index = max(index - 1, 0)\n case 0:\n status = random.choice(['done', 'fail', 'wait', 'idle'])\n case _:\n index = random.choice([1, 0])\n"... | 1 | 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... | F | {"registers": ["r1", "r2", "r3", "r4", "r5", "r6"], "initial": {"r1": "A", "r2": "B", "r3": "C", "r4": "D", "r5": "E", "r6": "F"}, "mappings": [{"X": "swap-first-two", "Y": "swap-outer", "Z": "swap-last-two"}, {"X": "rotate-left", "Y": "swap-outer", "Z": "swap-last-two"}, {"X": "rotate-right", "Y": "swap-last-two", "Z"... | 2 | instruct |
planar_geometry_relations | Given points: A=(9, 4); C=(8, 9); F=(-4, -1); H=(-25/68, 185/34); J=(108/17, -205/34); K=(-38/17, 8/17); O=(9/68, 33/17); Q=(-4, -9); R=(5/2, -7/17); S=(123/17, -22/17); U=(-7, 3); W=(1, 5); X=(383/68, 287/34); Y=(-38/17, 73/17); Z=(-4, -2).
Question: Which point is closer to H: X or O?
Answer is one of: X, O, tie. | O | {"points": {"A": "(9, 4)", "C": "(8, 9)", "F": "(-4, -1)", "H": "(-25/68, 185/34)", "J": "(108/17, -205/34)", "K": "(-38/17, 8/17)", "O": "(9/68, 33/17)", "Q": "(-4, -9)", "R": "(5/2, -7/17)", "S": "(123/17, -22/17)", "U": "(-7, 3)", "W": "(1, 5)", "X": "(383/68, 287/34)", "Y": "(-38/17, 73/17)", "Z": "(-4, -2)"}, "def... | 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:
Node 0 has directed edges to: 0.
Node 1 has directed edges to: 4.
Node 2 has directed edges to: 5.
Node 3 has directed edges to: 1.
Node 4 has directed edges to: 3.
Node ... | 2 | {"graph_description": "Node 0 has directed edges to: 0.\nNode 1 has directed edges to: 4.\nNode 2 has directed edges to: 5.\nNode 3 has directed edges to: 1.\nNode 4 has directed edges to: 3.\nNode 5 has directed edges to: 2.", "queries": [[5, 1]], "payload": {"graph": "Node 0 has directed edges to: 0.\nNode 1 has dire... | 0 | instruct |
belief_tracking | Initially, everyone knows that the ticket is in the case.
Story: Grace moves the ticket to the case. No one else sees the move. Grace moves the ticket to the case. Unknown to the others, Heidi watches through a window. Bob sends Heidi the message "I think the ticket is in the case", but it is not delivered. Grace move... | bin | {"agents": ["Dave", "Heidi", "Grace", "Bob"], "objects": ["ticket"], "containers": ["tin", "case", "bin", "jar"], "init": {"loc": {"ticket": "case"}}, "specs": [{"kind": "move", "actor": "Grace", "target": null, "policy": null, "report_type": null, "scene": "private_observation", "object": "ticket", "destination": "cas... | 0 | 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:
- or(X,X) -> X
- not(not(X)) -> X
- ... | if(and(not(true),or(and(c,c),and(b,b))),true,if(true,false,not(true))) | {"theory": "bool", "rules": "- or(X,X) -> X\n- not(not(X)) -> X\n- and(X,false) -> false\n- and(true,X) -> X\n- if(false,X,Y) -> Y\n- or(false,X) -> X\n- or(X,false) -> X", "term": "and(true,if(and(not(true),or(and(c,c),and(b,or(if(false,and(true,a),false),b)))),true,if(true,false,not(true))))", "normal_form": "if(and(... | 1 | instruct |
equation_system | Solve the following system of equations for the variable 'X5'.
System:
-36*X1 + 34*X2 + 17*X3 + 12*X4 + 77*X5 - 33*X6 - 1931 = 0
3*X1 + X4 - 6*X5 + 7*X6 + 201 = 0
6*X1 - 3*X2 - 4*X3 - 2*X4 - 14*X5 + 6*X6 + 358 = 0
-X1 - 8*X2 + X3 - 2*X4 + 4*X5 - 8*X6 - 192 = 0
-6*X1 + 2*X2 + 2*X3 + 13*X5 - 10*X6 - 385 = 0
... | 19 | {"equations": ["-36*X1 + 34*X2 + 17*X3 + 12*X4 + 77*X5 - 33*X6 - 1931 = 0", "3*X1 + X4 - 6*X5 + 7*X6 + 201 = 0", "6*X1 - 3*X2 - 4*X3 - 2*X4 - 14*X5 + 6*X6 + 358 = 0", "-X1 - 8*X2 + X3 - 2*X4 + 4*X5 - 8*X6 - 192 = 0", "-6*X1 + 2*X2 + 2*X3 + 13*X5 - 10*X6 - 385 = 0", "X1 + 2*X2 - X3 - 3*X5 + 3*X6 + 104 = 0", "-3*X2 + X3 ... | 4 | instruct |
most_probable_evidence | Factor a is independently true with probability 0.3.
Factor b is independently true with probability 0.7.
Factor c is independently true with probability 0.7.
Factor d is independently true with probability 0.6.
Factor e is independently true with probability 0.7.
The observation holds exactly when (if ((factor c is fa... | 0 2 5 7 9 | {"problog": "0.3::a.\n0.7::b.\n0.7::c.\n0.6::d.\n0.7::e.\nobserved :- ((((\\+c;\\+e),\\+d),\\+(b));(\\+(((\\+c;\\+e),\\+d)),(\\+(c),a))).\nevidence(observed,true).", "english": "Factor a is independently true with probability 0.3.\nFactor b is independently true with probability 0.7.\nFactor c is independently true wit... | 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:
- cat(X,eps) -> X
- rev(eps) -> eps
... | upper(eps) | {"theory": "string", "rules": "- cat(X,eps) -> X\n- rev(eps) -> eps\n- upper(upper(X)) -> upper(X)\n- cat(eps,X) -> X\n- lower(lower(X)) -> lower(X)\n- cat(cat(X,Y),Z) -> cat(X,cat(Y,Z))\n- quote(quote(X)) -> quote(X)", "term": "cat(upper(cat(eps,eps)),cat(eps,eps))", "normal_form": "upper(eps)", "used": ["cat_eps_r", ... | 0 | instruct |
logic_qa | Premise:
David is kappa tagged.
David is bravo tagged.
David is delta tagged.
Bruno is alpha-linked to Farah.
Farah is charlie tagged.
Alice is not bravo tagged.
Alice is gamma tagged.
Farah is alpha tagged.
For all x, if x is kappa tagged and x is bravo tagged, then x is foxtrot tagged.
For all x, if x is foxtrot tagg... | David, Farah | {"premise": ["David is kappa tagged.", "David is bravo tagged.", "David is delta tagged.", "Bruno is alpha-linked to Farah.", "Farah is charlie tagged.", "Alice is not bravo tagged.", "Alice is gamma tagged.", "Farah is alpha tagged.", "For all x, if x is kappa tagged and x is bravo tagged, then x is foxtrot tagged.", ... | 2 | instruct |
sequential_induction | Infer U[n]. Max recurrence degree: 3. Ops: +, -, *.
Use U[n - 1] ... U[n - 3] and n. Give the simplified polynomial RHS.
Sequence: [1, 6, 7, -30, -72, -110, 72, 357, 688, -891, -3870, -7931]
Initial terms: [1, 6, 7]
The answer is the RHS only. | -3 * n**2 - n * U[n - 3] | {"first elements": [1, 6, 7, -30, -72, -110, 72, 357, 688, -891, -3870, -7931], "degree of recursion": 3, "initial terms": [1, 6, 7], "canonical cost": 7, "canonical max cost": 7, "_time": 0.00793313980102539, "_task": "sequential_induction", "_level": 2, "_config": {"level": 2, "seed": null, "size": null, "mode": "sim... | 2 | instruct |
planar_geometry_relations | Given points: B=(-6, 8); G=(-4, 7); H=(-5, 15/2); J=(-21/2, -12); L=(7, -7); M=(-19/4, -33/4); P=(3, -7); Q=(-17/4, -17/2); S=(-3, -7); U=(-11/7, -7); Y=(2, -5).
Question: Which point is closer to Q: S or M?
Answer is one of: S, M, tie. | M | {"points": {"B": "(-6, 8)", "G": "(-4, 7)", "H": "(-5, 15/2)", "J": "(-21/2, -12)", "L": "(7, -7)", "M": "(-19/4, -33/4)", "P": "(3, -7)", "Q": "(-17/4, -17/2)", "S": "(-3, -7)", "U": "(-11/7, -7)", "Y": "(2, -5)"}, "definitions": [], "query": "Which point is closer to Q: S or M?", "instruction": "Answer is one of: S, ... | 2 | instruct |
belief_tracking | Initially, everyone knows that the note is in the vase.
Story: Heidi moves the note to the vase. No one else sees the move. Alice moves the note to the vase. Unknown to the others, Eve watches through a window. Eve sends Heidi the message "I think the note is in the vase", but it is not delivered. Alice moves the note... | bag | {"agents": ["Alice", "Heidi", "Eve"], "objects": ["note"], "containers": ["vase", "bag", "drawer"], "init": {"loc": {"note": "vase"}}, "specs": [{"kind": "move", "actor": "Heidi", "target": null, "policy": null, "report_type": null, "scene": "private_observation", "object": "note", "destination": "vase", "observers": [... | 0 | instruct |
controlled_code_execution | Predict the value returned by this Python call.
```python
def endpoint():
state = [5, 1, 1, 5]
for v0 in [-5, -2]:
state[0] = 2 * state[0] + v0
state[2] += state[0]
bias1 = 1
def f1(x):
return x + bias1 + state[1]
bias1 += -5
state[0] = f1(state[0])
alias2 = state
... | [1, 1, 14, 10] | {"code": "def endpoint():\n state = [5, 1, 1, 5]\n for v0 in [-5, -2]:\n state[0] = 2 * state[0] + v0\n state[2] += state[0]\n bias1 = 1\n def f1(x):\n return x + bias1 + state[1]\n bias1 += -5\n state[0] = f1(state[0])\n alias2 = state\n state = state[:]\n state[0] += -4... | 2 | 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... | E | {"registers": ["r1", "r2", "r3", "r4", "r5", "r6"], "initial": {"r1": "A", "r2": "B", "r3": "C", "r4": "D", "r5": "E", "r6": "F"}, "mappings": [{"X": "rotate-left", "Y": "rotate-right", "Z": "swap-first-two"}, {"X": "swap-first-two", "Y": "rotate-left", "Z": "swap-last-two"}], "program": [{"kind": "op", "operation": 0}... | 1 | instruct |
equation_system | Solve the following system of equations for the variable 'X2'.
System:
X1 + 3*X4 + 36 = 0
2*X1 + X2 + 11*X3 + 3*X4 + 250 = 0
-2*X1 + X2 + X3 - 6*X4 - 74 = 0
-X1 + X3 - 3*X4 - 12 = 0
X1 - X2 - 4*X3 + 4*X4 - 14 = 0
The answer is the value of X2, or 'No solution' / 'Multiple solutions'. | 26 | {"equations": ["X1 + 3*X4 + 36 = 0", "2*X1 + X2 + 11*X3 + 3*X4 + 250 = 0", "-2*X1 + X2 + X3 - 6*X4 - 74 = 0", "-X1 + X3 - 3*X4 - 12 = 0", "X1 - X2 - 4*X3 + 4*X4 - 14 = 0"], "query_variable": "X2", "full_solution_map": {"X1": 24, "X2": 26, "X3": -24, "X4": -20}, "case": "unique", "cot": "1. Forward:\nR2 -= 2*R1\nR3 -= -... | 2 | instruct |
equation_system | Solve the following system of equations for the variable 'X4'.
System:
X1 - 3*X2 + 10*X3 - 7*X4 - 233 = 0
-4*X1 + 8*X2 - 26*X3 + 25*X4 + 623 = 0
X2 - 4*X3 + X4 + 93 = 0
2*X1 - 4*X2 + 13*X3 - 12*X4 - 307 = 0
X1 - 4*X2 + 13*X3 - 9*X4 - 308 = -8
The answer is the value of X4, or 'No solution' / 'Multiple solut... | No solution | {"equations": ["X1 - 3*X2 + 10*X3 - 7*X4 - 233 = 0", "-4*X1 + 8*X2 - 26*X3 + 25*X4 + 623 = 0", "X2 - 4*X3 + X4 + 93 = 0", "2*X1 - 4*X2 + 13*X3 - 12*X4 - 307 = 0", "X1 - 4*X2 + 13*X3 - 9*X4 - 308 = -8"], "query_variable": "X4", "full_solution_map": null, "case": "inconsistent", "_time": 0.06835150718688965, "_task": "eq... | 2 | instruct |
grid_navigation | Grid [0,4]x[0,4], N=+y, E=+x.
Initial Facts:
- B is left of A.
- A is left of C.
- C is right of B.
- A is below C.
- A is below B.
- A starts at (3, 1).
- B is below C.
Steps:
1. A jumps to C's position offset by (-1, 0).
What is the final spatial relation of A to B? The answer is (horizontal, vertical), where horiz... | (right, above) | {"answer_type": "relation", "query_a": "A", "query_b": "B", "grid": 4, "objects": ["A", "B", "C"], "facts": [{"k": "h", "a": "B", "b": "A", "r": "left"}, {"k": "h", "a": "A", "b": "C", "r": "left"}, {"k": "h", "a": "C", "b": "B", "r": "right"}, {"k": "v", "a": "A", "b": "C", "r": "below"}, {"k": "v", "a": "A", "b": "B"... | 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:
Nodes [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] and directed edges: (0, 6), (1, 9), (2, 5), (3, 10), (4, 4), (5, 7), (6, 3), (7, 11), (8, 8), (9, 2), (10, 0), (11, 1).
Quer... | 11 6 0 8 | {"graph_description": "Nodes [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] and directed edges: (0, 6), (1, 9), (2, 5), (3, 10), (4, 4), (5, 7), (6, 3), (7, 11), (8, 8), (9, 2), (10, 0), (11, 1).", "queries": [[9, 4], [6, 8], [6, 3], [8, 8]], "payload": {"graph": "Nodes [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] and directed edges... | 6 | instruct |
string_transduction | String: quiet pixel signal amber
Operations:
- sort descending
- caesar shift by 1
Answer with the final string, excluding spaces. | yvutsrqonmmjjjhfffcbb | {"mode": "program", "source": "quiet pixel signal amber", "ops": ["sort descending", "caesar shift by 1"], "noop_rate": 0.0, "local_change_flags": [true, true], "effective_flags": [true, true], "effective_op_count": 2, "dead_op_count": 0, "cancelled_pair_count": 0, "required_effective_ops": 1, "exclude_spaces": true, "... | 0 | instruct |
table_qa | Execute this SQL query on the table named dataframe:
Table 1:
customer,status,unit_price,qty
C002,cancelled,8,2
C001,cancelled,15,3
C002,pending,106,102
C002,pending,29,5
C004,pending,13,6
C003,pending,20,7
C001,pending,27,8
C002,pending,11,9
C001,pending,18,10
C001,pending,25,11
C002,pending,9,12
C003,pending,16,13
C... | 3 | {"table": "customer,status,unit_price,qty\nC002,cancelled,8,2\nC001,cancelled,15,3\nC002,pending,106,102\nC002,pending,29,5\nC004,pending,13,6\nC003,pending,20,7\nC001,pending,27,8\nC002,pending,11,9\nC001,pending,18,10\nC001,pending,25,11\nC002,pending,9,12\nC003,pending,16,13\nC004,pending,23,14\n", "tables": ["custo... | 2 | instruct |
controlled_code_execution | Predict the value returned by this Python call.
```python
def endpoint():
state = [-2, -2, -4]
alias0 = state
state = state[:]
state[0] += 4
alias0[2] += state[0]
state[2] += alias0[0]
for v1 in [2, -2, -4]:
state[2] = 2 * state[2] + v1
state[1] += state[2]
return state
`... | [2, -82, -48] | {"code": "def endpoint():\n state = [-2, -2, -4]\n alias0 = state\n state = state[:]\n state[0] += 4\n alias0[2] += state[0]\n state[2] += alias0[0]\n for v1 in [2, -2, -4]:\n state[2] = 2 * state[2] + v1\n state[1] += state[2]\n return state\n", "phenomena": ["rebinding versus ali... | 1 | instruct |
combinatorics_formula | Which expression counts the outcomes? C(n,k) is unordered; P(n,k) is ordered.
Problem:
A club picks one of 4 projects, names one of 12 members to lead it, and assigns 4 other members as an unordered team.
Options:
A. 4*12*C(11,4)
B. 4*12*P(11,4)
C. 4*12*C(12,4)
D. 12*C(11,4)
Answer A-D. | A | {"family": "project_chair_committee", "structural_depth": 3, "program_type": "ProjectChairCommittee", "program": {"projects": 4, "population": 12, "committee_size": 4}, "correct_expression": "4*12*C(11,4)", "correct_option_index": 0, "correct_option_label": "A", "correct_features": {"top_operator": "product", "ast_size... | 5 | instruct |
defeasible_nli | An `unless` condition must be shown to block its rule.
Facts:
Elena is alpha-tagged and foxtrot-tagged.
Bruno is alpha-tagged, bravo-tagged, foxtrot-tagged, gamma-tagged, and lambda-tagged.
Clara is gamma-tagged and bravo-tagged.
David is alpha-tagged.
Alice is lambda-tagged.
Elena is alpha-linked to Bruno.
Rules:
Al... | Yes | {"premise": ["Elena is alpha tagged.", "Bruno is alpha tagged.", "Bruno is bravo tagged.", "Elena is foxtrot tagged.", "Bruno is foxtrot tagged.", "Bruno is gamma tagged.", "Elena is alpha-linked to Bruno.", "Bruno is lambda tagged.", "Clara is gamma tagged.", "David is alpha tagged.", "Alice is lambda tagged.", "Clara... | 1 | instruct |
multistep_abduction | Premise:
[0] farah is verified.
[1] alice is verified.
[2] george is trusted.
[3] david is not careful.
[4] alice trusts bruno.
[5] bruno advises elena.
[6] george is verified.
[7] elena is not trusted.
[8] Every verified entity is quiet.
[9] Being quiet implies being active.
Hypothesis:
elena is active.
Candidate Fa... | 5 | {"premise": ["farah is verified.", "alice is verified.", "george is trusted.", "david is not careful.", "alice trusts bruno.", "bruno advises elena.", "george is verified.", "elena is not trusted.", "Every verified entity is quiet.", "Being quiet implies being active."], "hypothesis": "elena is active.", "candidates": ... | 3 | instruct |
logic_qa | Premise:
elena is careful.
elena is trusted.
elena is eligible.
alice does not stand in the visits relation to farah.
alice is verified.
For all x, if x is careful and x is trusted, then x is approved.
From x is approved and x is eligible, it follows that x is active.
From x is careful and x is alert, it follows that x... | elena | {"premise": ["elena is careful.", "elena is trusted.", "elena is eligible.", "alice does not stand in the visits relation to farah.", "alice is verified.", "For all x, if x is careful and x is trusted, then x is approved.", "From x is approved and x is eligible, it follows that x is active.", "From x is careful and x i... | 2 | instruct |
dynamic_programming | States: A B C
Observations: 2 2 1 1 0
Start: A=1 B=0 C=-1
Transitions (rows=from, columns=A B C):
A: -2 -3 -1
B: -3 1 0
C: 1 -2 -3
Emissions (rows=state, columns=0..2):
A: -3 1 1
B: -1 0 1
C: 3 2 2
Score a state sequence by start + emissions + transitions. Find the maximum-score sequence; ties are lexicographic. The an... | B B C A C | {"labels": ["A", "B", "C"], "obs": [2, 2, 1, 1, 0], "start": [1, 0, -1], "trans": [[-2, -3, -1], [-3, 1, 0], [1, -2, -3]], "emit": [[-3, 1, 1], [-1, 0, 1], [3, 2, 2]], "_time": 0.0002562999725341797, "_task": "dynamic_programming", "_level": 0, "_config": {"level": 0, "seed": null, "size": null, "n_states": 3, "n_symbo... | 0 | instruct |
defeasible_nli | An `unless` condition must be shown to block its rule.
Facts:
George is trained, a bird, not abnormal, and approved.
Farah is trained, flagged, a bird, a penguin, and careful.
David is blocked.
Bruno is flagged and a bird.
Clara is not approved.
Alice is not flagged.
Elena is a penguin.
George helps Farah.
Alice helps... | Yes | {"premise": ["george is trained.", "farah is trained.", "farah is flagged.", "george is bird.", "farah is bird.", "farah is penguin.", "george helps farah.", "farah is careful.", "david is blocked.", "bruno is flagged.", "clara is not approved.", "alice helps david.", "bruno is bird.", "george is not ab bird.", "george... | 6 | instruct |
inverse_math | Find an antiderivative F(x) of f(x) = sqrt(1/cos(x))*tan(x)/2.
The answer is an expression in x (omit the constant).
Use plain notation, e.g. 3*x^2*exp(x) + log(x)/2. | sqrt(1/cos(x)) | {"mode": "integral", "integrand": "sqrt(1/cos(x))*tan(x)/2", "_time": 0.10779809951782227, "_task": "inverse_math", "_level": 2, "_config": {"level": 2, "seed": null, "size": 2.6}, "_prompt_tokens": 59, "_answer_tokens": 7, "_cot_tokens": 0, "_generator_name": "reasoning_core", "_generator_version": "0.5.0", "_generato... | 2 | instruct |
attribute_grammar | A parse tree is evaluated with an attribute grammar over integer values. Two attributes are inherited (passed down): ctx, an integer that is 0 at the root, and env, a mapping from variable names to values that is empty at the root. One attribute is synthesized (passed up): the node's value. Rules:
- N(v): a leaf whose ... | 13 | {"mode": "integer", "tree": "env(-1, sub(env(-3, [Q]env(2, let(z, add(N(0), N(-9)), sub(N(2), V(z))))), sub(N(-2), env(1, add(env(3, N(1)), sub(N(9), N(1)))))))", "marked": true, "_time": 0.0006058216094970703, "_task": "attribute_grammar", "_level": 6, "_config": {"level": 6, "seed": null, "size": null, "depth": 7, "m... | 6 | instruct |
process_inversion | Jar A starts with 2 stamps, jar B starts with 4 stamps. Then:
Step 1: 14 stamps were added to jar A.
Step 2: 3 stamps were removed from jar B.
Step 3: 7 stamps were added to jar A.
Step 4: the count in jar B was tripled.
Step 5: some stamps were added to jar B.
Step 6: the count in jar B was cut to a quarter.
At the en... | 12 | {"unit": "stamps", "names": "AB", "start": [2, 4], "steps": [["add", 0, 14], ["sub", 1, 3], ["add", 0, 7], ["mul", 1, 3], ["add", 1, 9], ["div", 1, 4]], "final": [23, 3], "hidden": ["step", 4], "q_step": 5, "q_jar": 1, "_time": 0.0004050731658935547, "_task": "process_inversion", "_level": 3, "_config": {"level": 3, "s... | 3 | instruct |
logic_qa | Premise:
elena is approved.
elena is active.
elena is trusted.
alice is trusted.
bruno is careful.
Whenever x is approved and x is active, x is verified.
Anyone who is verified and trusted is alert.
From x advises y and y helps z, it follows that x does not stand in the trusts relation to z.
Question:
How many entitie... | 1 | {"premise": ["elena is approved.", "elena is active.", "elena is trusted.", "alice is trusted.", "bruno is careful.", "Whenever x is approved and x is active, x is verified.", "Anyone who is verified and trusted is alert.", "From x advises y and y helps z, it follows that x does not stand in the trusts relation to z."]... | 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: (despite[iUr]|whether\b) | whether | {"regex": "(despite[iUr]|whether\\b)", "string": "whether", "answer_length_bucket": "3+", "answer_first_kind": "lower", "_time": 0.0027387142181396484, "_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": ... | 0 | instruct |
belief_tracking | Initially, everyone knows that the map is in the tin.
Story: Carol moves the map to the case. No one else sees the move. Carol sends Heidi the message "I think the map is in the case", but it is not delivered. Alice moves the map to the case. Alice and Heidi watch together and can see one another. Alice moves the map ... | jar | {"agents": ["Carol", "Alice", "Heidi", "Eve", "Grace"], "objects": ["map"], "containers": ["box", "tin", "chest", "case", "jar", "bowl"], "init": {"loc": {"map": "tin"}}, "specs": [{"kind": "move", "actor": "Carol", "target": null, "policy": null, "report_type": null, "scene": "private_observation", "object": "map", "d... | 2 | instruct |
logic_qa | Premise:
Bruno is gamma-linked to Clara.
Clara is bravo tagged.
Clara is echo tagged.
David is echo tagged.
Clara is charlie tagged.
Anyone gamma-linked to a bravo tagged person is delta tagged.
Anyone who is delta tagged is charlie tagged.
Anyone who is charlie tagged is echo tagged.
Question:
How many entities can b... | 3 | {"premise": ["Bruno is gamma-linked to Clara.", "Clara is bravo tagged.", "Clara is echo tagged.", "David is echo tagged.", "Clara is charlie tagged.", "Anyone gamma-linked to a bravo tagged person is delta tagged.", "Anyone who is delta tagged is charlie tagged.", "Anyone who is charlie tagged is echo tagged."], "ques... | 0 | instruct |
qualitative_reasoning | There are 6 entities labeled 0 through 5.
Read 'i rel j' as 'entity i is rel to entity j'.
Facts:
- 5 starts 1
- 0 starts 5
- 4 overlapped-by 5
- 2 overlapped-by 5
- 3 started-by 5
- 1 equals 3
What is the temporal relation of interval 1 to interval 0?
The answer is exactly one of: after, before, contains, during, equ... | started-by | {"calculus": "allen_time", "topic": "time intervals", "phrasing": "the temporal relation of interval {i} to interval {j}", "n_entities": 6, "hops": 2, "n_revealed": 6, "entities": [[-4, -1], [-4, 4], [-1, 1], [-4, 4], [-1, 3], [-4, 0]], "revealed": [[5, 1, "starts"], [0, 5, "starts"], [4, 5, "overlapped-by"], [2, 5, "o... | 1 | 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: b alpha a, b alpha d, c beta b, c beta d
M1: a alpha b,... | M2 | {"cases": [{"id": "M0", "context": [["alpha", "b", "a"], ["alpha", "b", "d"], ["beta", "c", "b"], ["beta", "c", "d"]], "consequence": ["alpha", "b", "d"]}, {"id": "M1", "context": [["alpha", "a", "b"], ["alpha", "c", "b"], ["beta", "b", "a"], ["beta", "c", "e"]], "consequence": ["alpha", "e", "b"]}, {"id": "M2", "conte... | 0 | instruct |
belief_tracking | Initially, everyone knows that the card is in the basket.
Story: Bob moves the card to the basket. No one else sees the move. Frank moves the card to the box. Frank and Carol watch together and can see one another. Frank moves the card to the basket. Frank and Carol watch together and can see one another. Frank moves ... | box | {"agents": ["Carol", "Frank", "Bob"], "objects": ["card"], "containers": ["cabinet", "basket", "box"], "init": {"loc": {"card": "basket"}}, "specs": [{"kind": "move", "actor": "Bob", "target": null, "policy": null, "report_type": null, "scene": "private_observation", "object": "card", "destination": "basket", "observer... | 1 | instruct |
table_qa | Execute this SQL query on the table named dataframe:
Table 1:
[
{
"qty":"2.00",
"category":"Food"
},
{
"qty":"3.00",
"category":"Food"
},
{
"qty":"4.00",
"category":"Food"
},
{
"qty":"5.00",
"category":"Electronics"
},
... | 2 | {"table": "[\n {\n \"qty\":\"2.00\",\n \"category\":\"Food\"\n },\n {\n \"qty\":\"3.00\",\n \"category\":\"Food\"\n },\n {\n \"qty\":\"4.00\",\n \"category\":\"Food\"\n },\n {\n \"qty\":\"5.00\",\n \"category\":\"Electronics\"\n },\n {\n... | 1 | instruct |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.