task large_stringclasses 49
values | prompt large_stringlengths 38 7.56k | answer large_stringlengths 0 1.6k | metadata large_stringlengths 491 170k | level int64 0 4 | mode large_stringclasses 1
value |
|---|---|---|---|---|---|
combinatorics_formula_selection | Which expression counts the outcomes? Answer A-D.
C(n,k): unordered; P(n,k): ordered.
Problem:
Walk east or north from (0,0) to (7,8), stopping at (3,5) on the way. Count the routes.
Options:
A. C(8,3)*C(6,4)
B. C(8,3)*C(7,4)
C. C(15,7)
D. C(7,3)*C(7,4) | B | {"family": "path_through_point", "structural_depth": 2, "program_type": "ThroughPointPath", "program": {"right": 7, "up": 8, "point_right": 3, "point_up": 5}, "correct_expression": "C(8,3)*C(7,4)", "correct_option_index": 1, "correct_features": {"top_operator": "product", "ast_size": 7, "contains_combination": true, "c... | 0 | instruct |
metamath_entailment | Does the conjecture follow using only the listed premises and rules?
Rules instantiate only by renaming variables.
The answer is True or False.
Premises:
1. ctx => P2(x, D1)
2. P3(y, x)
3. ctx => P3(y, z)
4. P3(u, z)
5. ctx => P3(x, z)
Allowed Rules:
r1: P3(u, z); ctx => P3(u, y); ctx => P3(z, x) ==> ctx => P3(y, x)
... | False | {"premises": ["ctx => P2(x, D1)", "P3(y, x)", "ctx => P3(y, z)", "P3(u, z)", "ctx => P3(x, z)"], "raw_premises": [["|-", "(", "ph", "->", "D", "e.", "RR", ")"], ["|-", "C", "=", "D"], ["|-", "(", "ph", "->", "C", "=", "B", ")"], ["|-", "A", "=", "B"], ["|-", "(", "ph", "->", "D", "=", "B", ")"]], "rules": ["r1", "r2", ... | 0 | instruct |
analogical_case_matching | Which case matches Query under consistent entity/relation renaming and per-relation direction reversal? Answer with its ID, or None.
M0: a alpha c, a alpha f, d beta c, b gamma f, e gamma f
M1: c alpha b, f beta a, f beta b, f beta d, f gamma d
M2: e alpha a, e alpha c, f alpha d, a beta c, f gamma b
M3: f alpha c, d ... | M0 | {"cases": [{"id": "M0", "context": [["alpha", "a", "c"], ["alpha", "a", "f"], ["beta", "d", "c"], ["gamma", "b", "f"], ["gamma", "e", "f"]], "consequence": ["gamma", "a", "d"]}, {"id": "M1", "context": [["alpha", "c", "b"], ["beta", "f", "a"], ["beta", "f", "b"], ["beta", "f", "d"], ["gamma", "f", "d"]], "consequence":... | 2 | instruct |
multistep_nli | Premise:
clara is a parent of bruno.
bruno is a parent of elena.
elena is a parent of farah.
alice is not patient.
bruno is careful.
bruno is kind.
For all x, y, if x is a parent of y, then x is an ancestor of y.
For all x, y, z, if x is a parent of y and y is an ancestor of z, then x is an ancestor of z.
From p is a p... | Yes | {"premise": ["clara is a parent of bruno.", "bruno is a parent of elena.", "elena is a parent of farah.", "alice is not patient.", "bruno is careful.", "bruno is kind.", "For all x, y, if x is a parent of y, then x is an ancestor of y.", "For all x, y, z, if x is a parent of y and y is an ancestor of z, then x is an an... | 2 | instruct |
table_qa | Execute this SQL query on the table named dataframe:
Table 1:
{"date": "25 janv. 2025", "qty": "2", "row_id": "R0000", "unit_price": "39.62", "country": "Germany", "status": "paid", "category": "Clothing"}
{"date": "4 mai 2026", "qty": "5", "row_id": "R0001", "unit_price": "53.63", "country": "France", "status": "paid... | Electronics | {"table": "{\"date\": \"25 janv. 2025\", \"qty\": \"2\", \"row_id\": \"R0000\", \"unit_price\": \"39.62\", \"country\": \"Germany\", \"status\": \"paid\", \"category\": \"Clothing\"}\n{\"date\": \"4 mai 2026\", \"qty\": \"5\", \"row_id\": \"R0001\", \"unit_price\": \"53.63\", \"country\": \"France\", \"status\": \"paid... | 2 | instruct |
parsing_derivation | (START)
start
(GRAMMAR)
R0: seq -> expr seq
R1: expr -> '<' seq '>'
R2: start -> seq
R3: seq ->
R4: expr -> '(' seq ')'
R5: expr -> '[' seq ']'
(STRING)
( ) ( )
(QUESTION)
The answer is the rule labels used in the leftmost derivation of STRING, in order, separated by spaces. | R2 R0 R4 R3 R0 R4 R3 R3 | {"label": "unambiguous", "tokens": ["(", ")", "(", ")"], "g": "seq -> \nexpr -> '(' seq ')'\nseq -> expr seq\nstart -> seq\nexpr -> '[' seq ']'\nexpr -> '<' seq '>'", "start": "start", "labeled_g": "R0: seq -> expr seq\nR1: expr -> '<' seq '>'\nR2: start -> seq\nR3: seq -> \nR4: expr -> '(' seq ')'\nR5: expr -> '[' seq... | 0 | instruct |
table_equivalence | Do these tables contain the same data?
Ignore row order, column order, and table syntax; match values by column name.
Treat numeric grouping and trailing zeros as formatting, ISO and English month-name dates as dates, and — and NULL as missing. Repeated rows count.
Table A:
event_date,amount,qty
2025-07-23,576.73,394
... | Yes | {"table_a": "event_date,amount,qty\n2025-07-23,576.73,394\n\u2014,427.63,717\n2024-11-13,1586.21,597\n2025-03-28,593.88,949\n", "table_b": "amount|qty|event_date\n593.88|949.00|Mar 28, 2025\n1,586.21|597.00|Nov 13, 2024\n576.73|394.00|Jul 23, 2025\n427.63|717.00|NULL\n", "format_a": "to_csv", "format_b": "to_pipe", "mu... | 0 | instruct |
qualitative_causal_reasoning | Assume linear causal relations, independent noise, and no exact cancellations.
X10 directly decreases X2; X12 directly decreases X8; X13 directly decreases X1; X3 directly decreases X11; X4 directly increases X9; X5 directly increases X6; X5 directly increases X7; X6 directly increases X1; X6 directly decreases X12.
... | no_effect | {"edges": [["X10", "X2", "-"], ["X12", "X8", "-"], ["X13", "X1", "-"], ["X3", "X11", "-"], ["X4", "X9", "+"], ["X5", "X6", "+"], ["X5", "X7", "+"], ["X6", "X1", "+"], ["X6", "X12", "-"]], "nodes": ["X0", "X1", "X10", "X11", "X12", "X13", "X2", "X3", "X4", "X5", "X6", "X7", "X8", "X9"], "query": {"kind": "intervention",... | 1 | instruct |
regex_following | The answer is the shortest non-empty visible non-whitespace ASCII string that fully matches this regular expression, with lexicographic tie-breaks: \].*? | ] | {"regex": "\\].*?", "string": "]", "_time": 0.005178213119506836, "_task": "regex_following", "_level": 2, "_config": {"level": 2, "seed": null, "size": null, "n_ex": 10, "max_depth": 7, "min_depth": 5, "n_alpha": 4, "max_answer_len": 24, "max_synth_nodes": 200000, "require_unique": true}, "_prompt_tokens": 32, "_answe... | 2 | instruct |
unification_entailment | Compute a most general unifier of the equations. Apply it to both sides of the candidate equality. Answer Yes if the instantiated candidate terms are identical, otherwise answer No. The equations are guaranteed to be unifiable.
Equations:
- p(x1, c) = p(x1, x0)
Candidate:
c = x0 | Yes | {"answer": "Yes", "equations": ["p(x1, c) = p(x1, x0)"], "candidate": "c = x0", "num_equations": 1, "num_variables": 2, "num_bindings_in_mgu": 1, "max_term_depth": 1, "candidate_depth": 0, "trace_steps": 2, "num_decompositions": 1, "num_alias_bindings": 0, "num_sharing_constraints": 0, "num_redundant_equations": 0, "di... | 0 | instruct |
game_best_move | In this graph game, choose player's best move. Player chooses on player turns; opponent chooses on opponent turns. Opponent minimizes player score.
Start: n3. Turns alternate player, opponent. Move along one edge per turn, for at most 3 moves. Play ends upon reaching a leaf or the move horizon; in either case, player'... | n4 | {"rules": "role(player).\nrole(opponent).\ninit(at(n3)).\ninit(step(t0)).\ninit(control(player)).\nsucc(t0,t1). succ(t1,t2). succ(t2,t3).\nedge(n0,n4). edge(n1,n3). edge(n1,n4). edge(n1,n8). edge(n2,n6). edge(n2,n8). edge(n3,n4). edge(n3,n6). edge(n4,n7). edge(n5,n6). edge(n5,n7). edge(n5,n8).\nleaf(n6). leaf(n7). leaf... | 2 | instruct |
most_probable_evidence | Factor c is independently true with probability 0.4.
Factor f is independently true with probability 0.7.
Factor e is independently true with probability 0.7.
The observation holds exactly when ((factor c or factor f) holds and factor e is false).
We observe it.
Which hidden fact values form the most probable complete ... | 1 3 4 | {"problog": "0.4::c.\n0.7::f.\n0.7::e.\nobserved :- ((c;f),\\+e).\nevidence(observed,true).", "english": "Factor c is independently true with probability 0.4.\nFactor f is independently true with probability 0.7.\nFactor e is independently true with probability 0.7.\nThe observation holds exactly when ((factor c or fac... | 1 | instruct |
lambda_reduction | Reduce the following untyped λ-term to β-normal form.
Syntax: `\x.body` is λx.body; juxtaposition is left-associative application; free identifiers are constants.
Term: ((d (\v0.((((\_1.d) (b c)) ((v0 ((\_3.(d ((\_6._6) (((\_5._5) ((((\_8.(\_7._8)) v0) a) v0)) _3)))) (v0 ((\_0._0) (v0 ((\_4.v0) c)))))) ((\_2.v0) d))) ... | ((d (\x0.((d ((x0 (d ((x0 x0) (x0 (x0 x0))))) x0)) x0))) a) | {"term": "((d (\\v0.((((\\_1.d) (b c)) ((v0 ((\\_3.(d ((\\_6._6) (((\\_5._5) ((((\\_8.(\\_7._8)) v0) a) v0)) _3)))) (v0 ((\\_0._0) (v0 ((\\_4.v0) c)))))) ((\\_2.v0) d))) v0))) a)", "normal_form": "((d (\\x0.((d ((x0 (d ((x0 x0) (x0 (x0 x0))))) x0)) x0))) a)", "beta_steps": 9, "has_shadowing": false, "shadowing": 0, "ca... | 3 | instruct |
set_missing_element | Answer with the missing elements in the ordered span of [198, 190, 187, 193, 197, 182, 199, 194, 180, 186, 183, 188, 192, 191, 185, 181, 196] as a Python set. | {184, 189, 195} | {"element_list": [198, 190, 187, 193, 197, 182, 199, 194, 180, 186, 183, 188, 192, 191, 185, 181, 196], "missing_count": 3, "_time": 0.0004031658172607422, "_task": "set_missing_element", "_level": 3, "_config": {"level": 3, "seed": null, "size": null, "domain_size": 675, "set_size": 20, "n_domains": 5, "prob_no_missin... | 3 | instruct |
defeasible_nli | An `unless` condition must be shown to block its rule.
Facts:
Elena is alpha-tagged and foxtrot-tagged.
David is alpha-tagged, bravo-tagged, foxtrot-tagged, gamma-tagged, and lambda-tagged.
Alice is delta-tagged and bravo-tagged.
Clara is echo-tagged.
Bruno is gamma-tagged.
Elena is alpha-linked to David.
Rules:
Alph... | No | {"premise": ["Elena is alpha tagged.", "David is alpha tagged.", "David is bravo tagged.", "Elena is foxtrot tagged.", "David is foxtrot tagged.", "David is gamma tagged.", "Elena is alpha-linked to David.", "David is lambda tagged.", "Alice is delta tagged.", "Clara is echo tagged.", "Bruno is gamma tagged.", "Alice i... | 1 | instruct |
game_forced_win | In this graph game, decide whether player can force a win. Player chooses on player turns; opponent chooses on opponent turns. Opponent minimizes player score. A win means final player score is greater than 50.
Start: n1. Turns alternate player, opponent. Move along one edge per turn, for at most 3 moves. Play ends up... | Yes | {"rules": "role(player).\nrole(opponent).\ninit(at(n1)).\ninit(step(t0)).\ninit(control(player)).\nsucc(t0,t1). succ(t1,t2). succ(t2,t3).\nedge(n0,n2). edge(n0,n3). edge(n1,n2). edge(n1,n4). edge(n2,n3). edge(n3,n5). edge(n3,n6).\nleaf(n4). leaf(n5). leaf(n6).\nvalue(n0,40). value(n1,0). value(n2,40). value(n3,40). val... | 0 | instruct |
graph_successors | For each query (x, k), give the k-th successor of x by following directed edges k times.
Answer with space-separated integers in query order.
Graph:
Adjacency Dictionary (source to targets): {0: [7], 1: [2], 2: [3], 3: [1], 4: [6], 5: [0], 6: [5], 7: [4]}
Queries:
[(4, 4), (1, 1)] | 7 2 | {"graph_description": "Adjacency Dictionary (source to targets): {0: [7], 1: [2], 2: [3], 3: [1], 4: [6], 5: [0], 6: [5], 7: [4]}", "queries": [[4, 4], [1, 1]], "payload": {"graph": "Adjacency Dictionary (source to targets): {0: [7], 1: [2], 2: [3], 3: [1], 4: [6], 5: [0], 6: [5], 7: [4]}", "queries": "[(4, 4), (1, 1)]... | 2 | instruct |
math_word_problem | Hana has 3 times as many tiles as Zara. Nina has 2 times as many tiles as Hana. Carlos has half as many tiles as Hana. Mei has half as many tiles as Zara. Diego has a quarter as many tiles as Mei. Mei has 24 tiles. How many tiles does Diego have? Answer with a number. | 6 | {"family": "relational", "unit": "tiles", "names": ["Zara", "Hana", "Carlos", "Mei", "Nina", "Diego"], "relations": [["times", "Hana", "Zara", 3, null], ["times", "Nina", "Hana", 2, null], ["frac", "Carlos", "Hana", 2, null], ["frac", "Mei", "Zara", 2, null], ["frac", "Diego", "Mei", 4, null]], "given": "Mei", "asked":... | 4 | instruct |
qualitative_reasoning | There are 6 entities labeled 0 through 5.
Read 'i rel j' as 'entity i is rel to entity j'.
Facts:
- 3 finished-by 5
- 2 after 5
- 0 finished-by 2
- 4 meets 0
- 1 overlapped-by 3
- 1 contains 5
- 0 overlapped-by 1
- 4 equals 5
What is the relation of the vertical extent of box 1 to that of box 4?
The answer is exactly ... | contains | {"calculus": "allen_y", "topic": "vertical extents of 2D boxes", "phrasing": "the relation of the vertical extent of box {i} to that of box {j}", "n_entities": 6, "hops": 5, "n_revealed": 8, "entities": [[-3, 2, 1, 3], [-1, 2, -1, 2], [-2, 3, 2, 3], [0, 2, -3, 1], [-3, -2, 0, 1], [1, 3, 0, 1]], "revealed": [[3, 5, "fin... | 1 | instruct |
string_transduction | String: cbbcbabcad
Operations:
- replace a with d
- caesar shift by 3
- dedupe adjacent repeats
Answer with the final string. | fefegefg | {"mode": "program", "source": "cbbcbabcad", "ops": ["replace a with d", "caesar shift by 3", "dedupe adjacent repeats"], "noop_rate": 0.0, "exclude_spaces": false, "_time": 0.0006940364837646484, "_task": "string_transduction", "_level": 1, "_config": {"level": 1, "seed": null, "size": null, "length": 10, "n_ops": 3, "... | 1 | instruct |
code_analysis | Program:
```python
import random
mode, status = 'done', 'green'
def step():
global mode, status
status = random.choice(['green', 'red', 'amber', 'blue'])
if (mode != 'fail') and (mode == 'wait'):
status = random.choice(['green', 'red', 'amber', 'blue'])
else:
match status:
... | [('done', 'green'), ('idle', 'amber'), ('wait', 'blue')] | {"program": "import random\n\nmode, status = 'done', 'green'\n\ndef step():\n global mode, status\n status = random.choice(['green', 'red', 'amber', 'blue'])\n if (mode != 'fail') and (mode == 'wait'):\n status = random.choice(['green', 'red', 'amber', 'blue'])\n else:\n match status:\n ... | 1 | instruct |
table_equivalence | Do these tables contain the same data?
Ignore row order, column order, and table syntax; match values by column name.
Treat numeric grouping and trailing zeros as formatting, ISO and English month-name dates as dates, and — and NULL as missing. Repeated rows count.
Table A:
event_date amount company
Aug 12, 2025... | Yes | {"table_a": "event_date amount company\nAug 12, 2025 1,742.47 NULL\nMay 21, 2026 344.17 Smith, Taylor and Jordan\nDec 30, 2024 1,367.22 Bennett and Sons\nDec 30, 2024 1,367.22 Bennett and Sons", "table_b": "event_date: 2024-12-30; company: Bennett and Sons; amount: 1367.22\nevent_date: 2025-08-12; compa... | 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] and directed edges: (0, 4), (1, 6), (2, 7), (3, 1), (4, 2), (5, 0), (6, 5), (7, 3).
Queries:
[(2, 3), (0, 4)] | 1 3 | {"graph_description": "Nodes [0, 1, 2, 3, 4, 5, 6, 7] and directed edges: (0, 4), (1, 6), (2, 7), (3, 1), (4, 2), (5, 0), (6, 5), (7, 3).", "queries": [[2, 3], [0, 4]], "payload": {"graph": "Nodes [0, 1, 2, 3, 4, 5, 6, 7] and directed edges: (0, 4), (1, 6), (2, 7), (3, 1), (4, 2), (5, 0), (6, 5), (7, 3).", "queries": "... | 2 | instruct |
code_runnability | Predict whether this Python call runs successfully or raises an exception.
```python
def f0(f: int, q: list) -> list:
f = f1(q, "cat") // f
return q
def f1(f: list, z: str) -> int:
a = f2(2) + f2(0)
return 0
def f2(i: int) -> str:
print(i)
return ""
def endpoint(x0: int, x1: list) -> list:
r... | ZeroDivisionError | {"code": "def f0(f: int, q: list) -> list:\n f = f1(q, \"cat\") // f\n return q\ndef f1(f: list, z: str) -> int:\n a = f2(2) + f2(0)\n return 0\ndef f2(i: int) -> str:\n print(i)\n return \"\"\ndef endpoint(x0: int, x1: list) -> list:\n return f0(x0, x1)\n", "args": [0, [1]], "call": "endpoint(0, [... | 2 | instruct |
graph_successors | For each query (x, k), give the k-th successor of x by following directed edges k times.
Answer with space-separated integers in query order.
Graph:
Directed Edges: 0->7, 1->4, 2->2, 3->8, 4->6, 5->0, 6->1, 7->3, 8->5
Queries:
[(8, 4), (8, 3), (1, 4)] | 3 7 4 | {"graph_description": "Directed Edges: 0->7, 1->4, 2->2, 3->8, 4->6, 5->0, 6->1, 7->3, 8->5", "queries": [[8, 4], [8, 3], [1, 4]], "payload": {"graph": "Directed Edges: 0->7, 1->4, 2->2, 3->8, 4->6, 5->0, 6->1, 7->3, 8->5", "queries": "[(8, 4), (8, 3), (1, 4)]"}, "nodes": [0, 1, 2, 3, 4, 5, 6, 7, 8], "edges": [[0, 7], ... | 3 | instruct |
set_missing_element | Answer with the missing elements in the ordered span of ['2021-05-18', '2021-05-17', '2021-05-16', '2021-05-19', '2021-05-11', '2021-05-15', '2021-05-13', '2021-05-12', '2021-05-14'] as a Python set. | {} | {"element_list": ["2021-05-18", "2021-05-17", "2021-05-16", "2021-05-19", "2021-05-11", "2021-05-15", "2021-05-13", "2021-05-12", "2021-05-14"], "missing_count": 0, "_time": 0.00035500526428222656, "_task": "set_missing_element", "_level": 1, "_config": {"level": 1, "seed": null, "size": null, "domain_size": 300, "set_... | 1 | instruct |
planar_geometry_relations | Given points: C=(-8, 5); D=(11, -6); G=(8, -11/2); H=(-8, -6); M=(8, 1); N=(1, -2); V=(8, 2); Y=(-6, 2).
Definitions: S is the translation of H by vector NV. K is the projection of V onto line NS. A is the translation of S by vector KV. T is the translation of K by vector YA.
Question: What type of angle is angle DGK?
... | obtuse | {"points": {"C": "(-8, 5)", "D": "(11, -6)", "G": "(8, -11/2)", "H": "(-8, -6)", "M": "(8, 1)", "N": "(1, -2)", "V": "(8, 2)", "Y": "(-6, 2)"}, "definitions": ["S is the translation of H by vector NV.", "K is the projection of V onto line NS.", "A is the translation of S by vector KV.", "T is the translation of K by ve... | 2 | instruct |
regex_reasoning | A = a|c|c?
B = b?|bbb
Do A and B accept exactly the same set of strings?
The answer is Yes or No. | No | {"qtype": "equivalence", "regex_a": "a|c|c?", "regex_b": "b?|bbb", "_time": 0.009298086166381836, "_task": "regex_reasoning", "_level": 0, "_config": {"level": 0, "seed": null, "size": null, "max_depth": 4, "min_depth": 2, "n_alpha": 3, "gramforge_algorithm": "sequential"}, "_prompt_tokens": 33, "_answer_tokens": 1, "_... | 0 | instruct |
sequential_induction | Infer U[n]. Max recurrence degree: 0. Ops: +, -, *.
Use n. Give the simplified polynomial RHS.
Sequence: [1, 5, 11, 19, 29, 41, 55, 71, 89, 109, 131, 155, 181, 209]
The answer is the RHS only. | n**2 + 3 * n + 1 | {"first elements": [1, 5, 11, 19, 29, 41, 55, 71, 89, 109, 131, 155, 181, 209], "degree of recursion": 0, "initial terms": [], "canonical cost": 7, "canonical max cost": 7, "_time": 0.06991958618164062, "_task": "sequential_induction", "_level": 3, "_config": {"level": 3, "seed": null, "size": null, "mode": "simple", "... | 3 | instruct |
analogical_case_matching | Which case matches Query under consistent entity/relation renaming and per-relation direction reversal? Answer with its ID.
M0: e alpha c, d beta e, a gamma b, e gamma d
M1: e alpha d, b beta a, c beta b, d beta a
M2: e alpha a, e alpha b, d beta a, e gamma d
M3: a alpha c, a beta c, d gamma a, d gamma c
Query: y delt... | M0 | {"cases": [{"id": "M0", "context": [["alpha", "e", "c"], ["beta", "d", "e"], ["gamma", "a", "b"], ["gamma", "e", "d"]], "consequence": ["gamma", "d", "e"]}, {"id": "M1", "context": [["alpha", "e", "d"], ["beta", "b", "a"], ["beta", "c", "b"], ["beta", "d", "a"]], "consequence": ["beta", "a", "d"]}, {"id": "M2", "contex... | 1 | instruct |
most_probable_outcome | A jar contains 9 green marbles and 6 yellow marbles.
Two marbles are picked without replacing the first marble.
Which statement is more likely?
A: at least one selected marble is green.
B: both selected marbles are yellow.
The answer is exactly one of: A, B, equal. | A | {"problog": "0.6::d1_x; 0.4::d1_y.\n0.571428571429::d2_x; 0.428571428571::d2_y :- d1_x.\n0.642857142857::d2_x; 0.357142857143::d2_y :- d1_y.\na :- d1_x.\na :- d2_x.\nb :- d1_y, d2_y.\nquery(a).\nquery(b).", "english": "A jar contains 9 green marbles and 6 yellow marbles.\nTwo marbles are picked without replacing the fi... | 4 | instruct |
parsing_derivation | (START)
start
(GRAMMAR)
R0: does -> 'does'
R1: wh_obj -> 'what'
R2: np_sg_subj -> pro_sg_subj
R3: question -> wh_obj does np_sg_subj v_trans_base
R4: root -> question '?'
R5: start -> root
R6: v_trans_base -> 'like'
R7: pro_sg_subj -> 'she'
(STRING)
what does she like ?
(QUESTION)
The answer is the rule labels used ... | R5 R4 R3 R1 R0 R2 R7 R6 | {"label": "unambiguous", "tokens": ["what", "does", "she", "like", "?"], "g": "question -> wh_obj does np_sg_subj v_trans_base\ndoes -> 'does'\nwh_obj -> 'what'\npro_sg_subj -> 'she'\nv_trans_base -> 'like'\nroot -> question '?'\nnp_sg_subj -> pro_sg_subj\nstart -> root", "start": "start", "labeled_g": "R0: does -> 'do... | 2 | instruct |
grid_navigation | Grid [0,7]x[0,7], N=+y, E=+x.
Initial Facts:
- D is below B.
- D starts at (3, 2).
- E is right of F.
- A is above D.
- D is above E.
- B is right of A.
- F starts at (1, 5).
- B is right of F.
- C is below F.
- E is below F.
- C is left of B.
Steps:
1. E jumps to A's position offset by (-1, 0).
2. F jumps to B's posi... | 1 | {"answer_type": "distance", "query_a": "A", "query_b": "C", "grid": 7, "objects": ["A", "B", "C", "D", "E", "F"], "facts": [{"k": "v", "a": "D", "b": "B", "r": "below"}, {"k": "coord", "a": "D", "p": [3, 2]}, {"k": "h", "a": "E", "b": "F", "r": "right"}, {"k": "v", "a": "A", "b": "D", "r": "above"}, {"k": "v", "a": "D"... | 3 | instruct |
constraint_satisfaction | In this 5x5 grid, each row and column contains 1..5 once.
Constraints:
1. r1c3 < r1c4
2. r4c3 < r4c2
3. r5c5 != 1
4. r2c1 = 5
5. r4c4 = 1
6. r4c1 < r5c1
7. r3c3 < r4c3
Question: What is r5c2?
Answer with one name or integer. | 1 | {"model_mode": "grid", "family": "grid", "solve_mode": "query", "query_type": "scalar", "structure_mode": null, "query": [5, 2], "query_var": "r5c2", "clues": ["r1c3 < r1c4", "r4c3 < r4c2", "r5c5 != 1", "r2c1 = 5", "r4c4 = 1", "r4c1 < r5c1", "r3c3 < r4c3"], "constraints": ["r1c3 < r1c4", "r4c3 < r4c2", "r5c5 != 1", "r2... | 3 | instruct |
code_execution | Predict the value returned by this Python call.
```python
def f0(a: str) -> list:
a = f1(4, [0, 1, 2])
return []
def f1(z: int, u: list) -> str:
if z > z:
z = z + 1
pass
return ""
def endpoint(x0: str) -> list:
return f0(x0)
```
Call: `endpoint('cyz')`
The answer is the exact Python `re... | [] | {"code": "def f0(a: str) -> list:\n a = f1(4, [0, 1, 2])\n return []\ndef f1(z: int, u: list) -> str:\n if z > z:\n z = z + 1\n pass\n return \"\"\ndef endpoint(x0: str) -> list:\n return f0(x0)\n", "args": ["cyz"], "call": "endpoint('cyz')", "steps": 6, "elapsed": 0.0013944140009698458, "stdou... | 1 | instruct |
combinatorics_formula_selection | Which expression counts the outcomes? Answer A-D.
C(n,k): unordered; P(n,k): ordered.
Problem:
Choose exactly one item from disjoint groups of sizes 9 and 7.
Options:
A. 9*7
B. 9+7
C. 2*9*7
D. 9+7-1 | B | {"family": "sum_rule", "structural_depth": 1, "program_type": "ChoiceRule", "program": {"kind": "sum", "first": 9, "second": 7}, "correct_expression": "9+7", "correct_option_index": 1, "correct_features": {"top_operator": "sum", "ast_size": 3, "contains_combination": false, "contains_permutation": false, "contains_powe... | 2 | instruct |
logic_nli | Premise:
Roger is the only person in the room.
if “Bellbridge's houses are all purple.” then ““The clock tower in Chronos does not strike thirteen times.” or “The lighthouse on Cape Sorrow glows green.” but not both”
Jesus is hotel tagged
Jesus is bravo tagged
no quiet person in the room is quiet
The clock tower in Chr... | No | {"verbalize_seed": 396728, "proof": {"proof": "% Running in auto input_syntax mode. Trying TPTP\n% Refutation found. Thanks to Tanya!\n% SZS status Unsatisfiable for tmpmqbujn36\n% SZS output start Proof for tmpmqbujn36\n2. room(roger) & ! [X0] : (room(X0) => X0 = roger) [input(axiom) 0]\n6. ! [X0] : (room(X0) => (quie... | 0 | instruct |
code_execution | Predict the value returned by this Python call.
```python
def f0(b: list, m: str) -> list:
a = 2
try:
print(a)
except Exception:
while a <= 3:
b = [k % 3 for k in range(5, 7)]
a = a + 2
return b
def f1(r: str) -> str:
try:
pass
except Exception:
... | [2] | {"code": "def f0(b: list, m: str) -> list:\n a = 2\n try:\n print(a)\n except Exception:\n while a <= 3:\n b = [k % 3 for k in range(5, 7)]\n a = a + 2\n return b\ndef f1(r: str) -> str:\n try:\n pass\n except Exception:\n b = [w + 2 for w in range(4, ... | 2 | instruct |
string_transduction | String: gedcbcggaagcgbcf
Operations:
- reverse
- dedupe adjacent repeats
- replace d with c
- rotate left by 2
- sort ascending
- sort descending
Answer with the final string. | ggggfecccccbba | {"mode": "program", "source": "gedcbcggaagcgbcf", "ops": ["reverse", "dedupe adjacent repeats", "replace d with c", "rotate left by 2", "sort ascending", "sort descending"], "noop_rate": 0.0, "exclude_spaces": false, "_time": 0.0014531612396240234, "_task": "string_transduction", "_level": 4, "_config": {"level": 4, "s... | 4 | instruct |
metamath_entailment | Does the conjecture follow using only the listed premises and rules?
Rules instantiate only by renaming variables.
The answer is True or False.
Premises:
1. ctx => P2(x, D1)
2. ctx => P2(y, D2)
3. ctx => P3(y, C0)
Allowed Rules:
r1: ctx => P2(x, D3); ctx => P2(y, D3); ctx => P3(y, C0) ==> ctx => P4(F2(F1(y, x), y), x... | True | {"premises": ["ctx => P2(x, D1)", "ctx => P2(y, D2)", "ctx => P3(y, C0)"], "raw_premises": [["|-", "(", "ph", "->", "A", "e.", "NN", ")"], ["|-", "(", "ph", "->", "B", "e.", "NN0", ")"], ["|-", "(", "ph", "->", "B", "=/=", "0", ")"]], "rules": ["r1", "r2", "r3", "r4"], "raw_rule_labels": ["divcan3d", "nn0cnd", "nnzd", ... | 1 | instruct |
set_expression | B = {'one', 'thirty', 'thirteen', 'thirty-three', 'forty', 'eighteen', 'forty-three', 'five', 'twenty-one'}
C = {'five', 'seven', 'forty-three', 'twenty-three', 'eighteen', 'fourteen', 'forty-seven', 'ten', 'twenty'}
Evaluate (C & B). | {'eighteen', 'five', 'forty-three'} | {"expr": "(C & B)", "list_mode": false, "C": ["five", "seven", "forty-three", "twenty-three", "eighteen", "fourteen", "forty-seven", "ten", "twenty"], "B": ["one", "thirty", "thirteen", "thirty-three", "forty", "eighteen", "forty-three", "five", "twenty-one"], "_time": 0.0005443096160888672, "_task": "set_expression", ... | 1 | instruct |
parsing_derivation | (START)
start
(GRAMMAR)
R0: expr -> '(' seq ')'
R1: seq ->
R2: start -> seq
R3: expr -> '[' seq ']'
R4: seq -> expr seq
R5: expr -> '<' seq '>'
(STRING)
( ) [ ] < >
(QUESTION)
The answer is the rule labels used in the leftmost derivation of STRING, in order, separated by spaces. | R2 R4 R0 R1 R4 R3 R1 R4 R5 R1 R1 | {"label": "unambiguous", "tokens": ["(", ")", "[", "]", "<", ">"], "g": "seq -> expr seq\nexpr -> '[' seq ']'\nexpr -> '<' seq '>'\nexpr -> '(' seq ')'\nstart -> seq\nseq -> ", "start": "start", "labeled_g": "R0: expr -> '(' seq ')'\nR1: seq -> \nR2: start -> seq\nR3: expr -> '[' seq ']'\nR4: seq -> expr seq\nR5: expr ... | 3 | instruct |
regex_reasoning | A = abac
B = (a)ab+
Is every string accepted by A also accepted by B?
The answer is Yes or No. | No | {"qtype": "containment", "regex_a": "abac", "regex_b": "(a)ab+", "_time": 0.011043071746826172, "_task": "regex_reasoning", "_level": 0, "_config": {"level": 0, "seed": null, "size": null, "max_depth": 4, "min_depth": 2, "n_alpha": 3, "gramforge_algorithm": "sequential"}, "_prompt_tokens": 30, "_answer_tokens": 1, "_ge... | 0 | 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:
- g(x0) = g(c)
Candidate:
x0 = g(c) | No | {"answer": "No", "equations": ["g(x0) = g(c)"], "candidate": "x0 = g(c)", "num_equations": 1, "num_variables": 1, "num_bindings_in_mgu": 1, "max_term_depth": 1, "candidate_depth": 1, "trace_steps": 2, "num_decompositions": 1, "num_alias_bindings": 0, "num_sharing_constraints": 0, "num_redundant_equations": 0, "difficul... | 0 | instruct |
constrained_continuation | (START)
start
(GRAMMAR)
seq ->
expr -> '[' seq ']'
expr -> '(' seq ')'
expr -> '<' seq '>'
seq -> expr seq
start -> seq
(PREFIX)
<
(TEMPLATE)
< ___ ___
(SUFFIX)
[ ] < > ( )
Fill in the 2 blanks (___) so that PREFIX + filled-TEMPLATE + SUFFIX is a grammatical sentence.
Answer with the blank tokens in order, space-... | > > | {"g": "seq -> \nexpr -> '[' seq ']'\nexpr -> '(' seq ')'\nexpr -> '<' seq '>'\nseq -> expr seq\nstart -> seq", "start": "start", "k": 3, "prefix": ["<"], "suffix": ["[", "]", "<", ">", "(", ")"], "hints": {"0": "<"}, "template": "< ___ ___", "blanks": [1, 2], "n_blanks": 2, "n_hints": 1, "n_options": 6, "_time": 0.0623... | 3 | instruct |
arithmetics | Evaluate lcm(7, 59) + abs(12) + -4.60.
The answer is a number. | 420.4 | {"expr": "lcm(7, 59) + abs(12) + -4.60", "display_expr": "lcm(7, 59) + abs(12) + -4.60", "digit_mode": "normal", "semantics": "exact", "semantic_cue": false, "out_decimals": 3, "height": 5, "cot": "lcm(7, 59) = 413\nabs(12) = 12\n413 + 12 = 425\n425 + -4.6 = 420.4", "_time": 0.0016937255859375, "_task": "arithmetics", ... | 0 | instruct |
planning | Objects:
object_1, object_2, object_3, object_4
Actions:
action_0(x0, x1)
Effect: fluent_2(x1, x0)
action_3(x0, x1)
Requires: fluent_2(x1, x0), fluent_0(x0)
Effect: fluent_5(x0), fluent_1(x1, x0)
Initial state:
True values: fluent_0(object_4)
All facts not listed under True values are false.
Goal:
fluent_1(obj... | action_0(object_4, object_1)
action_0(object_4, object_4)
action_0(object_4, object_2)
action_0(object_3, object_3)
action_3(object_4, object_2) | {"domain_seed": "8-280", "fluent_arity": 2, "na": 5, "planted_na": 5, "optimality_gap": 0, "target_na": 5, "generator_mode": "planted_walk_optimal", "trim_mode": "plan_cone", "problem_english": "Objects:\nobject_1, object_2, object_3, object_4\n\nActions:\naction_0(x0, x1)\n Effect: fluent_2(x1, x0)\naction_3(x0, x1)\... | 4 | instruct |
metamath_entailment | Does the conjecture follow using only the listed premises and rules?
Rules instantiate only by renaming variables.
The answer is True or False.
Premises:
1. ctx => P2(F1(x, C2), D1)
2. ctx => P2(x, D2)
3. ctx => P2(x, D3)
4. ctx => P2(F2(x), D4)
5. ctx => P3(C0, x)
6. ctx => P4(x, C0)
7. ctx => P2(x, D5)
8. ctx => P5(... | False | {"premises": ["ctx => P2(F1(x, C2), D1)", "ctx => P2(x, D2)", "ctx => P2(x, D3)", "ctx => P2(F2(x), D4)", "ctx => P3(C0, x)", "ctx => P4(x, C0)", "ctx => P2(x, D5)", "ctx => P5(y, C0)"], "raw_premises": [["|-", "(", "ph", "->", "(", "A", "^", "2", ")", "e.", "ZZ", ")"], ["|-", "(", "ph", "->", "A", "e.", "QQ", ")"], ["... | 2 | instruct |
graph_successors | For each query (x, k), give the k-th successor of x by following directed edges k times.
Answer with space-separated integers in query order.
Graph:
Directed Edges: 0->3, 1->7, 2->5, 3->1, 4->0, 5->4, 6->6, 7->2
Queries:
[(0, 1), (6, 4)] | 3 6 | {"graph_description": "Directed Edges: 0->3, 1->7, 2->5, 3->1, 4->0, 5->4, 6->6, 7->2", "queries": [[0, 1], [6, 4]], "payload": {"graph": "Directed Edges: 0->3, 1->7, 2->5, 3->1, 4->0, 5->4, 6->6, 7->2", "queries": "[(0, 1), (6, 4)]"}, "nodes": [0, 1, 2, 3, 4, 5, 6, 7], "edges": [[0, 3], [1, 7], [2, 5], [3, 1], [4, 0],... | 2 | instruct |
most_probable_evidence | Factor d is independently true with probability 0.1.
Factor f is independently true with probability 0.3.
Factor b is independently true with probability 0.7.
The observation holds exactly when ((factor d or factor f) holds and factor b is false).
We observe it.
Which hidden fact values form the most probable complete ... | 1 3 4 | {"problog": "0.1::d.\n0.3::f.\n0.7::b.\nobserved :- ((d;f),\\+b).\nevidence(observed,true).", "english": "Factor d is independently true with probability 0.1.\nFactor f is independently true with probability 0.3.\nFactor b is independently true with probability 0.7.\nThe observation holds exactly when ((factor d or fac... | 1 | instruct |
constrained_continuation | (START)
start
(GRAMMAR)
expr -> '(' seq ')'
start -> seq
seq ->
expr -> '<' seq '>'
seq -> expr seq
expr -> '[' seq ']'
(PREFIX)
<empty>
(TEMPLATE)
___ > ___ >
(SUFFIX)
<empty>
Fill in the 2 blanks (___) so that PREFIX + filled-TEMPLATE + SUFFIX is a grammatical sentence.
Answer with the blank tokens in order, sp... | < < | {"g": "expr -> '(' seq ')'\nstart -> seq\nseq -> \nexpr -> '<' seq '>'\nseq -> expr seq\nexpr -> '[' seq ']'", "start": "start", "k": 4, "prefix": [], "suffix": [], "hints": {"1": ">", "3": ">"}, "template": "___ > ___ >", "blanks": [0, 2], "n_blanks": 2, "n_hints": 2, "n_options": 18, "_time": 0.0758662223815918, "_ta... | 1 | instruct |
program_synthesis | Write f(s: str) -> str.
Target: return the minimum-cost StringFrag-v1 expression matching the examples.
Always allowed: s, string literals "", " ", "-", "_", and integer literals 0, 1, 2, 3.
Allowed operators for this problem:
- replace1: str.replace(str, str, 1)
- find: str.find(str)
- eq_str: str == str
Bounds: str... | def f(s: str) -> str:
return s.replace("_", "-", 1) | {"dsl": "StringFrag-v1", "cost": "nodes,ops,source_len,source_lex", "max_nodes": 11, "io_pairs": [[" abc", " abc"], ["__", "-_"]], "examples": [[" abc", " abc"], ["__", "-_"]], "holdout": [["", ""], [" ", " "], ["-", "-"], ["_", "-"], ["a", "a"], ["aa", "aa"], ["ab", "ab"], ["a-b", "a-b"], ["a_b", "a-b"], ["abc", "abc"... | 1 | instruct |
planning | Objects:
object_1, object_2, object_3, object_4, object_5
Actions:
action_0(x0, x1)
Requires: fluent_0(x1, x0), fluent_0(x0, x1)
Effect: not fluent_3
action_1(x0, x1)
Requires: fluent_4
Effect: fluent_2(x0)
action_2(x0, x1)
Requires: fluent_1(x0, x1), fluent_0(x0, x1), fluent_5
Effect: fluent_4, not fluent... | action_1(object_1, object_2)
action_1(object_4, object_2)
action_4(object_2, object_1)
action_1(object_2, object_2)
action_4(object_1, object_2)
action_4(object_4, object_4) | {"domain_seed": "7-311", "fluent_arity": 2, "na": 6, "planted_na": 6, "optimality_gap": 0, "target_na": 5, "generator_mode": "planted_walk_optimal", "trim_mode": "full", "problem_english": "Objects:\nobject_1, object_2, object_3, object_4, object_5\n\nActions:\naction_0(x0, x1)\n Requires: fluent_0(x1, x0), fluent_0(x... | 3 | instruct |
planar_geometry_relations | Given points: N=(3, -2); O=(-2, -3); Q=(5/9, 23/9); R=(-1, -1); S=(1/9, 31/9); W=(-3, -4); Z=(4, -3).
Definitions: J is the 90-degree counterclockwise rotation of W about R. K is the 90-degree counterclockwise rotation of N about R.
Question: What type of angle is angle SKQ?
Answer is one of: acute, right, obtuse. | obtuse | {"points": {"N": "(3, -2)", "O": "(-2, -3)", "Q": "(5/9, 23/9)", "R": "(-1, -1)", "S": "(1/9, 31/9)", "W": "(-3, -4)", "Z": "(4, -3)"}, "definitions": ["J is the 90-degree counterclockwise rotation of W about R.", "K is the 90-degree counterclockwise rotation of N about R."], "query": "What type of angle is angle SKQ?"... | 0 | instruct |
analogical_case_matching | Which case matches Query under consistent entity/relation renaming and per-relation direction reversal? Answer with its ID.
M0: a beta b, b beta c, c beta a, d beta a
M1: b alpha a, b alpha c, c alpha d, a beta d
M2: b alpha d, c alpha a, d alpha c, c beta b
M3: e alpha b, a beta c, c beta d, e beta f
Query: u delta z... | M2 | {"cases": [{"id": "M0", "context": [["beta", "a", "b"], ["beta", "b", "c"], ["beta", "c", "a"], ["beta", "d", "a"]], "consequence": ["beta", "a", "d"]}, {"id": "M1", "context": [["alpha", "b", "a"], ["alpha", "b", "c"], ["alpha", "c", "d"], ["beta", "a", "d"]], "consequence": ["alpha", "a", "b"]}, {"id": "M2", "context... | 1 | instruct |
belief_tracking | Initially, everyone knows that the coin is in the tray.
Story: Heidi moves the coin to the tray. No one else sees the move. Dave sends Carol the message "I think the coin is in the tray", but it is not delivered. Dave moves the coin to the tray. Unknown to the others, Carol watches through a window. Dave moves the coi... | tray | {"agents": ["Carol", "Dave", "Heidi"], "objects": ["coin"], "containers": ["vase", "jar", "tray"], "init": {"loc": {"coin": "tray"}}, "specs": [{"kind": "move", "actor": "Heidi", "target": null, "policy": null, "report_type": null, "scene": "private_observation", "object": "coin", "destination": "tray", "observers": []... | 1 | instruct |
code_runnability | Predict whether this Python call runs successfully or raises an exception.
```python
def f0(r: list, j: int) -> int:
j *= (4 if 2 * j > False else j)
j *= 3
j = j * 3
j += f1(j)
j = r.index(j)
return j + 3
def f1(b: int) -> int:
b += b
return b * 9
def f2(w: str, c: str) -> list:
pri... | ValueError | {"code": "def f0(r: list, j: int) -> int:\n j *= (4 if 2 * j > False else j)\n j *= 3\n j = j * 3\n j += f1(j)\n j = r.index(j)\n return j + 3\ndef f1(b: int) -> int:\n b += b\n return b * 9\ndef f2(w: str, c: str) -> list:\n print(c)\n return []\ndef endpoint(x0: list, x1: int) -> int:\n ... | 1 | instruct |
graph_successors | For each query (x, k), give the k-th successor of x by following directed edges k times.
Answer with space-separated integers in query order.
Graph:
Nodes: [0, 1, 2, 3, 4, 5, 6, 7, 8]
Adjacency Matrix (row indicates source, column indicates target):
[0, 0, 0, 0, 0, 0, 1, 0, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, ... | 5 8 | {"graph_description": "Nodes: [0, 1, 2, 3, 4, 5, 6, 7, 8]\nAdjacency Matrix (row indicates source, column indicates target):\n[0, 0, 0, 0, 0, 0, 1, 0, 0]\n[0, 0, 1, 0, 0, 0, 0, 0, 0]\n[0, 0, 0, 0, 0, 0, 0, 0, 1]\n[0, 0, 0, 0, 0, 0, 0, 1, 0]\n[0, 0, 0, 1, 0, 0, 0, 0, 0]\n[0, 0, 0, 0, 0, 1, 0, 0, 0]\n[1, 0, 0, 0, 0, 0, 0... | 3 | instruct |
equation_system | Solve the following system of equations for the variable 'X1'.
System:
X1 + X2 - 25 = 0
-6*X1 - 7*X2 + 166 = 0
2*X1 + 3*X2 - 66 = 0
The answer is the value of X1, or 'No solution' / 'Multiple solutions'. | 9 | {"equations": ["X1 + X2 - 25 = 0", "-6*X1 - 7*X2 + 166 = 0", "2*X1 + 3*X2 - 66 = 0"], "query_variable": "X1", "full_solution_map": {"X1": 9, "X2": 16}, "case": "unique", "cot": "1. Forward:\nR2 -= -6*R1\nR3 -= 2*R1\nR3 -= -1*R2\n\n2. Backward:\nX2 = 16\nX1 = 9", "_time": 0.027585744857788086, "_task": "equation_system"... | 0 | instruct |
set_missing_element | Answer with the missing elements in the ordered span of [610, 614, 613, 615, 612] as a Python set. | {611} | {"element_list": [610, 614, 613, 615, 612], "missing_count": 1, "_time": 0.0009310245513916016, "_task": "set_missing_element", "_level": 0, "_config": {"level": 0, "seed": null, "size": null, "domain_size": 200, "set_size": 6, "n_domains": 2, "prob_no_missing": 0.1}, "_prompt_tokens": 30, "_answer_tokens": 3, "_genera... | 0 | instruct |
belief_tracking | Initially, everyone knows that the coin is in the bin.
Story: Bob moves the coin to the box. No one else sees the move. Grace moves the coin to the jar. Unknown to the others, Dave watches through a window. Grace moves the coin to the bin. Unknown to the others, Dave watches through a window. Bob sends Carol the messa... | basket | {"agents": ["Carol", "Bob", "Grace", "Dave", "Eve"], "objects": ["coin"], "containers": ["jar", "tin", "basket", "bin", "box"], "init": {"loc": {"coin": "bin"}}, "specs": [{"kind": "move", "actor": "Bob", "target": null, "policy": null, "report_type": null, "scene": "private_observation", "object": "coin", "destination... | 1 | instruct |
graph_successors | For each query (x, k), give the k-th successor of x by following directed edges k times.
Answer with space-separated integers in query order.
Graph:
digraph { 0->5; 1->1; 2->3; 3->0; 4->6; 5->4; 6->2 }
Queries:
[(4, 1), (3, 3)] | 6 4 | {"graph_description": "digraph { 0->5; 1->1; 2->3; 3->0; 4->6; 5->4; 6->2 }", "queries": [[4, 1], [3, 3]], "payload": {"graph": "digraph { 0->5; 1->1; 2->3; 3->0; 4->6; 5->4; 6->2 }", "queries": "[(4, 1), (3, 3)]"}, "nodes": [0, 1, 2, 3, 4, 5, 6], "edges": [[0, 5], [1, 1], [2, 3], [3, 0], [4, 6], [5, 4], [6, 2]], "_tim... | 1 | instruct |
most_probable_evidence | Factor f is independently true with probability 0.7.
Factor c is independently true with probability 0.6.
Factor b is independently true with probability 0.1.
The observation holds exactly when (factor f or (factor c and factor b)).
We observe it.
Which hidden fact values form the most probable complete explanation?
H... | 1 2 4 | {"problog": "0.7::f.\n0.6::c.\n0.1::b.\nobserved :- (f;(c,b)).\nevidence(observed,true).", "english": "Factor f is independently true with probability 0.7.\nFactor c is independently true with probability 0.6.\nFactor b is independently true with probability 0.1.\nThe observation holds exactly when (factor f or (factor... | 2 | instruct |
math_word_problem | Iris has 10 more beads than Priya. Ravi has 9 fewer beads than Priya. Priya has 22 beads. How many beads does Ravi have? Answer with a number. | 13 | {"family": "relational", "unit": "beads", "names": ["Priya", "Ravi", "Iris"], "relations": [["more", "Iris", "Priya", 10, null], ["fewer", "Ravi", "Priya", 9, null]], "given": "Priya", "asked": "Ravi", "given_value": 22, "values": {"Priya": 22, "Ravi": 13, "Iris": 32}, "base": 22, "equation": "Eq(x, 22)", "_time": 0.00... | 1 | instruct |
graph_successors | For each query (x, k), give the k-th successor of x by following directed edges k times.
Answer with space-separated integers in query order.
Graph:
Adjacency Dictionary (source to targets): {0: [0], 1: [4], 2: [1], 3: [5], 4: [6], 5: [3], 6: [2]}
Queries:
[(2, 3)] | 6 | {"graph_description": "Adjacency Dictionary (source to targets): {0: [0], 1: [4], 2: [1], 3: [5], 4: [6], 5: [3], 6: [2]}", "queries": [[2, 3]], "payload": {"graph": "Adjacency Dictionary (source to targets): {0: [0], 1: [4], 2: [1], 3: [5], 4: [6], 5: [3], 6: [2]}", "queries": "[(2, 3)]"}, "nodes": [0, 1, 2, 3, 4, 5, ... | 1 | instruct |
metamath_entailment | Does the conjecture follow using only the listed premises and rules?
Rules instantiate only by renaming variables.
The answer is True or False.
Premises:
1. P1(x, D1)
2. P1(y, D2)
3. P1(z, D3)
Allowed Rules:
r1: P1(x, D1); P1(y, D1); P1(z, D1) ==> P4(P3(P2(x, y), P2(y, z)), P2(x, z))
r2: P1(x, D3) ==> P1(x, D1)
r3: P... | True | {"premises": ["P1(x, D1)", "P1(y, D2)", "P1(z, D3)"], "raw_premises": [["|-", "A", "e.", "RR"], ["|-", "B", "e.", "ZZ"], ["|-", "C", "e.", "NN"]], "rules": ["r1", "r2", "r3"], "raw_rule_labels": ["lttri", "nnrei", "zrei"], "rule_map": {"r1": "lttri", "r2": "nnrei", "r3": "zrei"}, "rule_schemas": {"r1": "P1(x, D1); P1(y... | 1 | instruct |
planar_geometry_relations | Given points: B=(4, -3); F=(-11/6, -1/3); G=(-2, 4); L=(-3, 0); R=(-7/3, -1/3); U=(-2, -3); Z=(5, 2).
Definitions: Y is the projection of G onto line ZU. P is the midpoint of G and U.
Question: What type of angle is angle RPF?
Answer is one of: acute, right, obtuse. | acute | {"points": {"B": "(4, -3)", "F": "(-11/6, -1/3)", "G": "(-2, 4)", "L": "(-3, 0)", "R": "(-7/3, -1/3)", "U": "(-2, -3)", "Z": "(5, 2)"}, "definitions": ["Y is the projection of G onto line ZU.", "P is the midpoint of G and U."], "query": "What type of angle is angle RPF?", "instruction": "Answer is one of: acute, right,... | 0 | instruct |
metamath_entailment | Does the conjecture follow using only the listed premises and rules?
Rules instantiate only by renaming variables.
The answer is True or False.
Premises:
1. P1(x, F1(y))
2. P1(y, F2(z))
3. ctx => P3(x, D3)
4. ctx => P3(x, D4)
5. P1(y, z)
6. P4(z, x)
7. ctx => P1(y, x)
8. ctx => P4(x, z)
9. P1(z, x)
Allowed Rules:
r1:... | False | {"premises": ["P1(x, F1(y))", "P1(y, F2(z))", "ctx => P3(x, D3)", "ctx => P3(x, D4)", "P1(y, z)", "P4(z, x)", "ctx => P1(y, x)", "ctx => P4(x, z)", "P1(z, x)"], "raw_premises": [["|-", "B", "=", "(", "toTG", "`", "A", ")"], ["|-", "A", "=", "(", "Base", "`", "C", ")"], ["|-", "(", "ph", "->", "B", "e.", "Grp", ")"], ["... | 3 | 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:
- concat: str + str
- substr: str[int:(int)+(int)]
- len: len(str)
- sub: int - int
Bounds:... | def f(s: str) -> str:
return (((s + "_") + "-") + " ") | {"dsl": "StringFrag-v1", "cost": "nodes,ops,source_len,source_lex", "max_nodes": 11, "io_pairs": [[" ", " _- "], [" abc", " abc_- "]], "examples": [[" ", " _- "], [" abc", " abc_- "]], "holdout": [["", "_- "], ["-", "-_- "], ["_", "__- "], ["a", "a_- "], ["aa", "aa_- "], ["ab", "ab_- "], ["a-b", "a-b_- "], ["a_b", "a_b... | 2 | instruct |
parsing_derivation | (START)
start
(GRAMMAR)
R0: decl_simple -> there are det_pl_indef n_thing_pl
R1: root -> decl '.'
R2: conj -> 'yet'
R3: are -> 'are'
R4: det_pl_indef -> 'some'
R5: there -> 'there'
R6: n_thing_pl -> 'ideas'
R7: start -> root
R8: decl -> decl_simple ',' conj decl_simple
(STRING)
there are some ideas , yet there are so... | R7 R1 R8 R0 R5 R3 R4 R6 R2 R0 R5 R3 R4 R6 | {"label": "unambiguous", "tokens": ["there", "are", "some", "ideas", ",", "yet", "there", "are", "some", "ideas", "."], "g": "conj -> 'yet'\ndet_pl_indef -> 'some'\nare -> 'are'\nstart -> root\nroot -> decl '.'\ndecl_simple -> there are det_pl_indef n_thing_pl\nn_thing_pl -> 'ideas'\nthere -> 'there'\ndecl -> decl_simp... | 4 | instruct |
planar_geometry_relations | Given points: C=(43/16, -35/8); D=(-2, -5/2); E=(-2, -8); F=(-10, -7); G=(-5, -12); L=(6, 2); P=(-8, -2); R=(3, 5); U=(-63/4, 3); V=(21/2, 0); W=(9, 6); Y=(-19/2, 1/2); Z=(408/77, 267/77).
Question: Do segments CD and YU intersect?
Endpoint contact and collinear overlap count as intersection. Answer is either Yes or No... | No | {"points": {"C": "(43/16, -35/8)", "D": "(-2, -5/2)", "E": "(-2, -8)", "F": "(-10, -7)", "G": "(-5, -12)", "L": "(6, 2)", "P": "(-8, -2)", "R": "(3, 5)", "U": "(-63/4, 3)", "V": "(21/2, 0)", "W": "(9, 6)", "Y": "(-19/2, 1/2)", "Z": "(408/77, 267/77)"}, "definitions": [], "query": "Do segments CD and YU intersect?", "in... | 3 | 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: ((b (\v0.((\_0.((\_4.((((\_5.v0) ((c (\v0.b)) (\v0.v0))) (\v1.(v0 b))) ((\_2._0) (a ((c ((\_3._4) (_4 ((_4 a) b)))) c))))) d)) (v0 v0)))) (\v0.((\_1.(... | ((b (\x0.((x0 (\x1.(x0 b))) (x0 x0)))) (\x2.(\x3.(c x2)))) | {"term": "((b (\\v0.((\\_0.((\\_4.((((\\_5.v0) ((c (\\v0.b)) (\\v0.v0))) (\\v1.(v0 b))) ((\\_2._0) (a ((c ((\\_3._4) (_4 ((_4 a) b)))) c))))) d)) (v0 v0)))) (\\v0.((\\_1.(\\v1._1)) (c v0))))", "normal_form": "((b (\\x0.((x0 (\\x1.(x0 b))) (x0 x0)))) (\\x2.(\\x3.(c x2))))", "beta_steps": 5, "has_shadowing": true, "shado... | 0 | 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(a, x1) = h(x4, x3)
- p(x2, x3) = p(x2, x1)
- h(x1, x0) = h(x3, x3)
- h(x4, a... | Yes | {"answer": "Yes", "equations": ["h(a, x1) = h(x4, x3)", "p(x2, x3) = p(x2, x1)", "h(x1, x0) = h(x3, x3)", "h(x4, a) = h(a, a)"], "candidate": "x0 = x3", "num_equations": 4, "num_variables": 5, "num_bindings_in_mgu": 3, "max_term_depth": 1, "candidate_depth": 0, "trace_steps": 5, "num_decompositions": 2, "num_alias_bind... | 1 | instruct |
parsing_derivation | (START)
S
(GRAMMAR)
R0: F -> E
R1: E -> 'environment'
R2: F -> 'interview'
R3: S -> E
R4: D -> '[' 'professional' ']'
R5: F -> '<' D '>' 'drug'
R6: B -> B E
R7: E -> '<' F '>'
(STRING)
< < interview > >
(QUESTION)
The answer is the rule labels used in the leftmost derivation of STRING, in order, separated by spaces. | R3 R7 R0 R7 R2 | {"label": "unambiguous", "tokens": ["<", "<", "interview", ">", ">"], "g": "E -> '<' F '>'\nB -> B E\nF -> 'interview'\nE -> 'environment'\nD -> '[' 'professional' ']'\nS -> E\nF -> E\nF -> '<' D '>' 'drug'", "start": "S", "labeled_g": "R0: F -> E\nR1: E -> 'environment'\nR2: F -> 'interview'\nR3: S -> E\nR4: D -> '[' ... | 3 | instruct |
most_probable_outcome | A jar contains 9 blue marbles and 3 red marbles.
Two marbles are picked without replacing the first marble.
Which statement is more likely?
A: at least one selected marble is blue.
B: both selected marbles are red.
The answer is exactly one of: A, B, equal. | A | {"problog": "0.75::d1_x; 0.25::d1_y.\n0.727272727273::d2_x; 0.272727272727::d2_y :- d1_x.\n0.818181818182::d2_x; 0.181818181818::d2_y :- d1_y.\na :- d1_x.\na :- d2_x.\nb :- d1_y, d2_y.\nquery(a).\nquery(b).", "english": "A jar contains 9 blue marbles and 3 red marbles.\nTwo marbles are picked without replacing the firs... | 4 | 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: red
- b2: red
- b3: blue
- b4: blue
- b5: green
- b6: green
Initial Sta... | x4 | {"family": "logical_winograd", "balls": ["b1", "b2", "b3", "b4", "b5", "b6"], "boxes": ["x1", "x2", "x3", "x4"], "colors": {"b1": "red", "b2": "red", "b3": "blue", "b4": "blue", "b5": "green", "b6": "green"}, "initial_placement": {"b1": "x1", "b2": "x2", "b3": "x1", "b4": "x2", "b5": "x3", "b6": "x2"}, "moves": ["Move ... | 2 | instruct |
graph_successors | For each query (x, k), give the k-th successor of x by following directed edges k times.
Answer with space-separated integers in query order.
Graph:
Nodes: [0, 1, 2, 3, 4, 5]
Adjacency Matrix (row indicates source, column indicates target):
[0, 0, 0, 1, 0, 0]
[1, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 1]
[0, 1, 0, 0, 0, 0]
[0... | 2 | {"graph_description": "Nodes: [0, 1, 2, 3, 4, 5]\nAdjacency Matrix (row indicates source, column indicates target):\n[0, 0, 0, 1, 0, 0]\n[1, 0, 0, 0, 0, 0]\n[0, 0, 0, 0, 0, 1]\n[0, 1, 0, 0, 0, 0]\n[0, 0, 0, 0, 1, 0]\n[0, 0, 1, 0, 0, 0]", "queries": [[5, 1]], "payload": {"graph": "Nodes: [0, 1, 2, 3, 4, 5]\nAdjacency Ma... | 0 | instruct |
syntax_error_detection | (START)
start
(GRAMMAR)
seq -> expr seq
expr -> '<' seq '>'
expr -> '[' seq ']'
expr -> '⟦' seq '⟧'
start -> seq
expr -> '⟪' seq '⟫'
expr -> '⟨' seq '⟩'
seq ->
expr -> '(' seq ')'
(STRING)
⟫ ⟪ ⟫ ⟪ < > ⟫ ⟨ ⟩
Answer OK, INCOMPLETE, or ERROR token for the first invalid token. If that token repeats in STRING, append it... | ERROR ⟫@1 | {"g": "seq -> expr seq\nexpr -> '<' seq '>'\nexpr -> '[' seq ']'\nexpr -> '\u27e6' seq '\u27e7'\nstart -> seq\nexpr -> '\u27ea' seq '\u27eb'\nexpr -> '\u27e8' seq '\u27e9'\nseq -> \nexpr -> '(' seq ')'", "start": "start", "tokens": ["\u27eb", "\u27ea", "\u27eb", "\u27ea", "<", ">", "\u27eb", "\u27e8", "\u27e9"], "error... | 4 | instruct |
most_probable_evidence | Factor d is independently true with probability 0.7.
Factor f is independently true with probability 0.3.
Factor a is independently true with probability 0.3.
The observation holds exactly when (factor d or (factor f or factor a)).
We observe it.
Which hidden fact values form the most probable complete explanation?
Hi... | 1 2 5 | {"problog": "0.7::d.\n0.3::f.\n0.3::a.\nobserved :- (d;(f;a)).\nevidence(observed,true).", "english": "Factor d is independently true with probability 0.7.\nFactor f is independently true with probability 0.3.\nFactor a is independently true with probability 0.3.\nThe observation holds exactly when (factor d or (factor... | 2 | instruct |
set_expression | A = {'male magazine', 'sweet way', 'close grandfather', 'administrative funeral', 'heavy tip', 'wonderful copy'}
B = {'previous value', 'great imagination', 'close grandfather', 'administrative funeral', 'heavy tip', 'wonderful copy'}
C = {'male magazine', 'great imagination', 'close grandfather', 'administrative funer... | {'great imagination', 'male magazine', 'previous value', 'wonderful copy'} | {"expr": "((A & C) ^ B)", "list_mode": false, "B": ["previous value", "great imagination", "close grandfather", "administrative funeral", "heavy tip", "wonderful copy"], "C": ["male magazine", "great imagination", "close grandfather", "administrative funeral", "heavy tip", "sexual recording"], "A": ["male magazine", "s... | 0 | instruct |
most_probable_evidence | Factor d is independently true with probability 0.6.
Factor e is independently true with probability 0.7.
Factor c is independently true with probability 0.4.
The observation holds exactly when (factor d and (factor e or factor c)).
We observe it.
Which hidden fact values form the most probable complete explanation?
H... | 1 2 4 | {"problog": "0.6::d.\n0.7::e.\n0.4::c.\nobserved :- (d,(e;c)).\nevidence(observed,true).", "english": "Factor d is independently true with probability 0.6.\nFactor e is independently true with probability 0.7.\nFactor c is independently true with probability 0.4.\nThe observation holds exactly when (factor d and (facto... | 1 | instruct |
regex_reasoning | A = bb??bc
B = b(b{1,2}c|c{2}ab+)
Is every string accepted by A also accepted by B?
The answer is Yes or No. | Yes | {"qtype": "containment", "regex_a": "bb??bc", "regex_b": "b(b{1,2}c|c{2}ab+)", "_time": 0.1648867130279541, "_task": "regex_reasoning", "_level": 1, "_config": {"level": 1, "seed": null, "size": null, "max_depth": 5, "min_depth": 3, "n_alpha": 3, "gramforge_algorithm": "sequential"}, "_prompt_tokens": 42, "_answer_toke... | 1 | instruct |
metamath_entailment | Does the conjecture follow using only the listed premises and rules?
Rules instantiate only by renaming variables.
The answer is True or False.
Premises:
1. ctx => P2(x, D1)
2. ctx => P2(y, D2)
Allowed Rules:
r1: ctx => P2(x, D3) ==> ctx => P2(x, D4)
r2: ctx => P2(x, D2) ==> ctx => P2(x, D3)
r3: ctx => P2(x, D1); ctx... | True | {"premises": ["ctx => P2(x, D1)", "ctx => P2(y, D2)"], "raw_premises": [["|-", "(", "ph", "->", "A", "e.", "CC", ")"], ["|-", "(", "ph", "->", "B", "e.", "NN", ")"]], "rules": ["r1", "r2", "r3", "r4"], "raw_rule_labels": ["nn0zd", "nnnn0d", "subeq0ad", "zcnd"], "rule_map": {"r1": "nn0zd", "r2": "nnnn0d", "r3": "subeq0a... | 2 | instruct |
sequential_induction | Infer U[n]. Max recurrence degree: 2. Ops: +, -, *.
Use U[n - 1] ... U[n - 2] and n. Give the simplified polynomial RHS.
Sequence: [5, -6, -32, -11, 92, 12, -602, -141, 4752, 1198, -47598, -13263, 571084, 172320]
Initial terms: [5, -6]
The answer is the RHS only. | -n * U[n - 2] - 7 * n - 8 | {"first elements": [5, -6, -32, -11, 92, 12, -602, -141, 4752, 1198, -47598, -13263, 571084, 172320], "degree of recursion": 2, "initial terms": [5, -6], "canonical cost": 7, "canonical max cost": 7, "_time": 4.435476779937744, "_task": "sequential_induction", "_level": 3, "_config": {"level": 3, "seed": null, "size": ... | 3 | instruct |
defeasible_nli | An `unless` condition must be shown to block its rule.
Facts:
Alice is trained, a bird, and trusted.
Bruno is trained, flagged, a bird, a penguin, and careful.
Clara is blocked and a penguin.
David is trained.
Alice helps Bruno.
Rules:
Trained people are trusted unless flagged.
Trusted people are approved unless bloc... | No | {"premise": ["alice is trained.", "bruno is trained.", "bruno is flagged.", "alice is bird.", "bruno is bird.", "bruno is penguin.", "alice helps bruno.", "bruno is careful.", "clara is blocked.", "clara is penguin.", "alice is trusted.", "david is trained.", "Whenever x is trained and it cannot be shown that x is flag... | 0 | instruct |
sequential_induction | Infer U[n]. Max recurrence degree: 0. Ops: +, -, *.
Use n. Give the simplified polynomial RHS.
Sequence: [-10, 6, 22, 38, 54, 70, 86, 102, 118, 134]
The answer is the RHS only. | 16 * n - 10 | {"first elements": [-10, 6, 22, 38, 54, 70, 86, 102, 118, 134], "degree of recursion": 0, "initial terms": [], "canonical cost": 7, "canonical max cost": 7, "_time": 0.05375075340270996, "_task": "sequential_induction", "_level": 1, "_config": {"level": 1, "seed": null, "size": null, "mode": "simple", "recurrence_depth... | 1 | 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. P1(x, F1(y))
2. P1(z, F2(y))
Rule Catalog:
- r1: P1(x, F2(u)) ==> P3(P2(u, D3), P4(x, D4))
... | D | {"premises": ["P1(x, F1(y))", "P1(z, F2(y))"], "raw_premises": [["|-", "B", "=", "(", "toTG", "`", "C", ")"], ["|-", "A", "=", "(", "Base", "`", "C", ")"]], "conjecture": "P3(P2(x, D3), P4(z, D4))", "raw_conjecture": ["|-", "(", "B", "e.", "Grp", "->", "A", "=/=", "(/)", ")"], "rule_map": {"r1": "grpbn0", "r2": "normcl... | 1 | instruct |
syntax_error_detection | (START)
start
(GRAMMAR)
who -> 'who'
question -> who vp_sg
vp_sg -> v_intr_sg opt_adv
opt_adv ->
start -> root
root -> question '?'
v_intr_sg -> 'runs'
(STRING)
who who ?
Answer OK, INCOMPLETE, or ERROR token for the first invalid token. If that token repeats in STRING, append its 1-based occurrence as @occurrence. | ERROR who@2 | {"g": "who -> 'who'\nquestion -> who vp_sg\nvp_sg -> v_intr_sg opt_adv\nopt_adv -> \nstart -> root\nroot -> question '?'\nv_intr_sg -> 'runs'", "start": "start", "tokens": ["who", "who", "?"], "error_index": 1, "_time": 0.0032300949096679688, "_task": "syntax_error_detection", "_level": 4, "_config": {"level": 4, "seed... | 4 | 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)
Bounds:... | def f(s: str) -> str:
return s[2:(2)+(3)].replace("_", "-", 1) | {"dsl": "StringFrag-v1", "cost": "nodes,ops,source_len,source_lex", "max_nodes": 10, "io_pairs": [[" ", ""], ["--", ""], ["a-b", "b"], [" abc", "bc"], ["b-c-ca", "c-c"], [" _b-aa__b___-c", "-b-"], ["-_ba_aba cc-cb ", "ba-"]], "examples": [[" ", ""], ["--", ""], ["a-b", "b"], [" abc", "bc"], ["b-c-ca", "c-c"], [" _b-a... | 1 | instruct |
parsing_derivation | (START)
start
(GRAMMAR)
R0: root -> decl '.'
R1: are -> 'are'
R2: decl_simple -> there are det_pl_indef n_thing_pl
R3: start -> root
R4: decl -> decl_simple ',' conj decl_simple
R5: n_thing_pl -> 'messages'
R6: det_pl_indef -> 'many'
R7: there -> 'there'
R8: conj -> 'and'
(STRING)
there are many messages , and there ... | R3 R0 R4 R2 R7 R1 R6 R5 R8 R2 R7 R1 R6 R5 | {"label": "unambiguous", "tokens": ["there", "are", "many", "messages", ",", "and", "there", "are", "many", "messages", "."], "g": "are -> 'are'\nroot -> decl '.'\ndecl -> decl_simple ',' conj decl_simple\ndecl_simple -> there are det_pl_indef n_thing_pl\nconj -> 'and'\nn_thing_pl -> 'messages'\nstart -> root\nthere ->... | 3 | instruct |
defeasible_nli | An `unless` condition must be shown to block its rule.
Facts:
David is alpha-tagged, foxtrot-tagged, lambda-tagged, and bravo-tagged.
George is alpha-tagged, delta-tagged, foxtrot-tagged, gamma-tagged, lambda-tagged, and kappa-tagged.
Farah is charlie-tagged and kappa-tagged.
David is alpha-linked to George.
Rules:
A... | No | {"premise": ["David is alpha tagged.", "George is alpha tagged.", "George is delta tagged.", "David is foxtrot tagged.", "George is foxtrot tagged.", "George is gamma tagged.", "David is alpha-linked to George.", "George is lambda tagged.", "Farah is charlie tagged.", "David is lambda tagged.", "Farah is kappa tagged."... | 3 | instruct |
equation_system | Solve the following system of equations for the variable 'X1'.
System:
11*X1 - 5*X2 + 37*X3 - 166 = 0
-2*X1 + X2 - 6*X3 + 23 = 0
5*X1 - 2*X2 + 16*X3 - 73 = 0
4*X1 - 2*X2 + 13*X3 - 54 = 0
The answer is the value of X1, or 'No solution' / 'Multiple solutions'. | -5 | {"equations": ["11*X1 - 5*X2 + 37*X3 - 166 = 0", "-2*X1 + X2 - 6*X3 + 23 = 0", "5*X1 - 2*X2 + 16*X3 - 73 = 0", "4*X1 - 2*X2 + 13*X3 - 54 = 0"], "query_variable": "X1", "full_solution_map": {"X1": -5, "X2": 15, "X3": 8}, "case": "unique", "cot": "1. Forward:\nR2 -= -2/11*R1\nR3 -= 5/11*R1\nR4 -= 4/11*R1\nR3 -= 3*R2\nR4 ... | 1 | instruct |
table_equivalence | Do these tables contain the same data?
Ignore row order, column order, and table syntax; match values by column name.
Treat numeric grouping and trailing zeros as formatting, ISO and English month-name dates as dates, and — and NULL as missing. Repeated rows count.
Table A:
event_date|amount|country|product|email
2025... | No | {"table_a": "event_date|amount|country|product|email\n2025-03-24|\u2014|Lebanon|Improve|bryantanner@example.net\n2026-02-26|1318.02|Tajikistan|Reason|uwilliams@example.net\n2025-06-10|2280.22|Falkland Islands (Malvinas)|Instead|davidcampbell@example.org\n2025-06-03|2081.18|Korea|Week|cheryl12@example.net\n2025-09-28|35... | 2 | instruct |
unification_entailment | Compute a most general unifier of the equations. Apply it to both sides of the candidate equality. Answer Yes if the instantiated candidate terms are identical, otherwise answer No. The equations are guaranteed to be unifiable.
Equations:
- h(b, x0) = h(b, x1)
Candidate:
x1 = x0 | Yes | {"answer": "Yes", "equations": ["h(b, x0) = h(b, x1)"], "candidate": "x1 = x0", "num_equations": 1, "num_variables": 2, "num_bindings_in_mgu": 1, "max_term_depth": 1, "candidate_depth": 0, "trace_steps": 2, "num_decompositions": 1, "num_alias_bindings": 1, "num_sharing_constraints": 0, "num_redundant_equations": 0, "di... | 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: 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,n1). edge(n0,n3). edge(n1,n4). edge(n1,n5). edge(n2,n4). edge(n3,n4). edge(n3,n6). edge(n4,n6). edge(n4,n7).\nleaf(n5). leaf(n6). leaf(n7).\nvalue(n0,50). value... | 1 | instruct |
sequential_induction | Infer U[n]. Max recurrence degree: 2. Ops: +, -, *.
Use U[n - 1] ... U[n - 2] and n. Give the simplified polynomial RHS.
Sequence: [-6, -1, -39, -29, -105, -85, -237, -197, -501, -421, -1029, -869]
Initial terms: [-6, -1]
The answer is the RHS only. | 2 * U[n - 2] - 27 | {"first elements": [-6, -1, -39, -29, -105, -85, -237, -197, -501, -421, -1029, -869], "degree of recursion": 2, "initial terms": [-6, -1], "canonical cost": 7, "canonical max cost": 7, "_time": 0.20345044136047363, "_task": "sequential_induction", "_level": 2, "_config": {"level": 2, "seed": null, "size": null, "mode"... | 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: 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,n3). edge(n0,n5). edge(n1,n6). edge(n1,n7). edge(n1,n10). edge(n2,n3). edge(n2,n9). edge(n3,n4). edge(n4,n5). edge(n4,n7). edge(n5,n6). edge(n5,n7). edge(n5,n9)... | 4 | instruct |
combinatorics_formula_selection | Which expression counts the outcomes? Answer A-D.
C(n,k): unordered; P(n,k): ordered.
Problem:
Count 4-person subsets of 14 that contain one, but not both, of Alice and Bob.
Options:
A. C(12,3)+C(12,3)
B. C(12,3)
C. C(12,3)+C(12,2)
D. C(14,4)-C(12,4) | A | {"family": "exclusive_committee", "structural_depth": 2, "program_type": "ExclusiveCommittee", "program": {"population": 14, "size": 4}, "correct_expression": "C(12,3)+C(12,3)", "correct_option_index": 0, "correct_features": {"top_operator": "sum", "ast_size": 7, "contains_combination": true, "contains_permutation": fa... | 4 | instruct |
most_probable_outcome | A box contains 2 yellow balls and 8 green balls.
Two balls are drawn without replacing the first ball.
Which statement is more likely?
A: at least one selected ball is yellow.
B: both selected balls are green.
The answer is exactly one of: A, B, equal. | B | {"problog": "0.2::d1_x; 0.8::d1_y.\n0.111111111111::d2_x; 0.888888888889::d2_y :- d1_x.\n0.222222222222::d2_x; 0.777777777778::d2_y :- d1_y.\na :- d1_x.\na :- d2_x.\nb :- d1_y, d2_y.\nquery(a).\nquery(b).", "english": "A box contains 2 yellow balls and 8 green balls.\nTwo balls are drawn without replacing the first bal... | 2 | instruct |
table_statistics | Table:
{"label": "L1", "L": 1.5, "D": -2.89, "E": -0.93, "N": 0.41, "M": -0.31, "K": -0.43}
{"label": "L3", "L": -1.33, "D": 0.41, "E": 3.48, "N": -1.0, "M": -2.14, "K": 0.12}
{"label": "L1", "L": 3.61, "D": -0.49, "E": -3.56, "N": 0.75, "M": 3.64, "K": 0.2}
{"label": "L3", "L": 1.31, "D": -2.15, "E": 2.36, "N": -0.12,... | E | {"table": "{\"label\": \"L1\", \"L\": 1.5, \"D\": -2.89, \"E\": -0.93, \"N\": 0.41, \"M\": -0.31, \"K\": -0.43}\n{\"label\": \"L3\", \"L\": -1.33, \"D\": 0.41, \"E\": 3.48, \"N\": -1.0, \"M\": -2.14, \"K\": 0.12}\n{\"label\": \"L1\", \"L\": 3.61, \"D\": -0.49, \"E\": -3.56, \"N\": 0.75, \"M\": 3.64, \"K\": 0.2}\n{\"lab... | 2 | instruct |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.