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 |
|---|---|---|---|---|---|
logic_qa | Premise:
lamp is left of box.
box is left of map.
Every left of relation creates a right of relation in the reverse direction.
From x is right of y, it follows that y is left of x.
Left Of relations followed by left of relations imply left of relations.
Question:
Which other entities can map be shown to be right of?
... | box, lamp | {"premise": ["lamp is left of box.", "box is left of map.", "Every left of relation creates a right of relation in the reverse direction.", "From x is right of y, it follows that y is left of x.", "Left Of relations followed by left of relations imply left of relations."], "question": "Which other entities can map be s... | 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: n4. Turns alternate player, opponent. Move along one edge per turn, for at most 4 moves. Play ends upon reaching a leaf or the move horizon; in either case, player'... | n9 | {"rules": "role(player).\nrole(opponent).\ninit(at(n4)).\ninit(step(t0)).\ninit(control(player)).\nsucc(t0,t1). succ(t1,t2). succ(t2,t3). succ(t3,t4).\nedge(n0,n9). edge(n1,n2). edge(n1,n3). edge(n1,n4). edge(n2,n5). edge(n2,n9). edge(n3,n6). edge(n3,n7). edge(n3,n8). edge(n4,n5). edge(n4,n7). edge(n4,n9). edge(n5,n8).... | 3 | instruct |
logic_qa | Premise:
bruno is trusted.
bruno is careful.
bruno is trained.
alice is eligible.
elena is trusted.
If a person is trusted and careful, then that person is verified.
Whenever x is verified and x is trained, x is eligible.
Whenever x is verified and x is approved, x is careful.
Anyone who is trained and alert is trusted... | 2 | {"premise": ["bruno is trusted.", "bruno is careful.", "bruno is trained.", "alice is eligible.", "elena is trusted.", "If a person is trusted and careful, then that person is verified.", "Whenever x is verified and x is trained, x is eligible.", "Whenever x is verified and x is approved, x is careful.", "Anyone who is... | 2 | instruct |
math_word_problem | Noah has 18 more cookies than Diego. Diego has a third as many cookies as Tara. Tara has 18 cookies. How many cookies does Noah have? Answer with a number. | 24 | {"family": "relational", "unit": "cookies", "names": ["Tara", "Diego", "Noah"], "relations": [["more", "Noah", "Diego", 18, null], ["frac", "Diego", "Tara", 3, null]], "given": "Tara", "asked": "Noah", "given_value": 18, "values": {"Tara": 18, "Diego": 6, "Noah": 24}, "base": 18, "query_distance": 2, "proof_core_size":... | 2 | instruct |
game_forced_win | In this graph game, decide whether player can force a win. Player chooses on player turns; opponent chooses on opponent turns. Opponent minimizes player score. A win means final player score is greater than 50.
Start: n1. Turns alternate player, opponent. Move along one edge per turn, for at most 4 moves. Play ends up... | No | {"rules": "role(player).\nrole(opponent).\ninit(at(n1)).\ninit(step(t0)).\ninit(control(player)).\nsucc(t0,t1). succ(t1,t2). succ(t2,t3). succ(t3,t4).\nedge(n0,n2). edge(n0,n8). edge(n1,n4). edge(n1,n6). edge(n2,n3). edge(n2,n5). edge(n2,n9). edge(n3,n4). edge(n3,n5). edge(n3,n8). edge(n4,n6). edge(n4,n9). edge(n5,n6).... | 3 | instruct |
math_word_problem | A jar holds some coins. quadrupled; then multiplied by 3; then 22 coins removed. The jar now holds 470 coins. How many coins did it start with? Answer with a number. | 41 | {"family": "process", "unit": "coins", "base": 41, "observed": 470, "inverse": true, "steps": [["mul", 4], ["mul", 3], ["sub", 22]], "expr": "12*x - 22", "equation": "Eq(12*x - 22, 470)", "_time": 0.004450559616088867, "_task": "math_word_problem", "_level": 3, "_config": {"level": 3, "seed": null, "size": null, "n_rel... | 3 | instruct |
inverse_math | Find an antiderivative F(x) of f(x) = x/sqrt(x*(x + sqrt(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(x^2 + x*sqrt(x^(-2))) | {"mode": "integral", "integrand": "x/sqrt(x*(x + sqrt(x^(-2))))", "_time": 1.0408570766448975, "_task": "inverse_math", "_level": 3, "_config": {"level": 3, "seed": null, "size": 3.4000000000000004}, "_prompt_tokens": 61, "_answer_tokens": 13, "_cot_tokens": 0, "_generator_name": "reasoning_core", "_generator_version":... | 3 | instruct |
systems_trace | A cache holds at most 4 keys and starts empty. On an access, a key already in the cache is a hit; otherwise it is a miss and the key is inserted, and if the cache is full you first evict the resident key whose most recent access is oldest (LRU). Accesses, in order: 3 2 2 3 5 6 5 4 1 4 0 2 3 2 6 2.
List the evicted keys... | 2 3 6 5 1 4 | {"system": "cache", "prompt": "A cache holds at most 4 keys and starts empty. On an access, a key already in the cache is a hit; otherwise it is a miss and the key is inserted, and if the cache is full you first evict the resident key whose most recent access is oldest (LRU). Accesses, in order: 3 2 2 3 5 6 5 4 1 4 0 2... | 4 | instruct |
inverse_math | Find an antiderivative F(x) of f(x) = sqrt(x).
The answer is an expression in x (omit the constant).
Use plain notation, e.g. 3*x^2*exp(x) + log(x)/2. | 2*x^(3/2)/3 | {"mode": "integral", "integrand": "sqrt(x)", "_time": 0.01596522331237793, "_task": "inverse_math", "_level": 0, "_config": {"level": 0, "seed": null, "size": 1.0}, "_prompt_tokens": 50, "_answer_tokens": 8, "_cot_tokens": 0, "_generator_name": "reasoning_core", "_generator_version": "0.5.0", "_generator_commit": "f9e9... | 0 | instruct |
combinatorics_formula | Write the counting expression. C(n,k) is unordered; P(n,k) is ordered.
Problem:
Choose one item from each of two labeled groups of sizes 5 and 3.
The answer must have the form:
X1X2X3
where:
X1 := 2 | 1 | 5
X2 := * | - | +
X3 := 2 | 3 | 1
Answer with the complete expression. | 5*3 | {"family": "product_rule", "structural_depth": 1, "program_type": "ChoiceRule", "program": {"kind": "product", "first": 5, "second": 3}, "correct_expression": "5*3", "correct_option_index": 2, "correct_option_label": "C", "correct_features": {"top_operator": "product", "ast_size": 3, "contains_combination": false, "con... | 0 | instruct |
code_analysis | Program:
```python
import random
color, flag, mode = 'closed', True, 'green'
def step():
global color, flag, mode
if (flag) and (mode == 'white'):
mode = random.choice(['green', 'amber', 'red', 'white', 'blue'])
if not flag:
mode = 'white'
return
elif color != 'clos... | [('busy', False, 'amber'), ('busy', False, 'white'), ('open', True, 'amber')] | {"program": "import random\n\ncolor, flag, mode = 'closed', True, 'green'\n\ndef step():\n global color, flag, mode\n if (flag) and (mode == 'white'):\n mode = random.choice(['green', 'amber', 'red', 'white', 'blue'])\n if not flag:\n mode = 'white'\n return\n elif color != ... | 4 | instruct |
parsing_derivation | (START)
start
(GRAMMAR)
R0: root ::= decl '.'
R1: n_sg_c ::= 'student'
R2: start ::= root
R3: det_sg_a ::= 'a'
R4: is ::= 'is'
R5: conj ::= 'but'
R6: there ::= 'there'
R7: decl_simple ::= there is det_sg_a n_sg_c
R8: decl ::= decl_simple ',' conj decl_simple
(STRING)
there is a student , but there is a student .
(QU... | R2 R0 R8 R7 R6 R4 R3 R1 R5 R7 R6 R4 R3 R1 | {"label": "unambiguous", "tokens": ["there", "is", "a", "student", ",", "but", "there", "is", "a", "student", "."], "g": "conj ::= 'but'\ndecl ::= decl_simple ',' conj decl_simple\ndet_sg_a ::= 'a'\nstart ::= root\nthere ::= 'there'\nroot ::= decl '.'\nn_sg_c ::= 'student'\nis ::= 'is'\ndecl_simple ::= there is det_sg_... | 1 | instruct |
process_inversion | Jar A starts with 4 apples, jar B starts with 3 apples. Then:
Step 1: 14 apples were added to jar B.
Step 2: 2 apples were removed from jar A.
Step 3: 16 apples were moved from jar B to jar A.
Step 4: the count in jar B was tripled.
Step 5: some apples were moved from jar A to jar B.
Step 6: 5 apples were moved from ja... | 8 | {"unit": "apples", "names": "AB", "start": [4, 3], "steps": [["add", 1, 14], ["sub", 0, 2], ["move", 1, 16, 0], ["mul", 1, 3], ["move", 0, 5, 1], ["move", 0, 5, 1], ["add", 0, 3]], "final": [11, 13], "hidden": ["step", 4], "q_step": 5, "q_jar": 1, "_time": 0.0002651214599609375, "_task": "process_inversion", "_level": ... | 3 | instruct |
analogical_case_matching | Which case can be embedded into Query? A case matches when every fact maps to a Query fact under one-to-one entity and relation renaming, with an optional consistent direction reversal for each relation. Query may contain additional facts. Answer with its ID.
M0: d alpha b, d beta c, f beta c, f beta e, e gamma a, e g... | M4 | {"cases": [{"id": "M0", "context": [["alpha", "d", "b"], ["beta", "d", "c"], ["beta", "f", "c"], ["beta", "f", "e"], ["gamma", "e", "a"], ["gamma", "e", "c"]], "consequence": ["beta", "e", "b"]}, {"id": "M1", "context": [["alpha", "d", "b"], ["beta", "a", "e"], ["beta", "c", "e"], ["beta", "d", "a"], ["beta", "d", "f"]... | 4 | instruct |
set_missing_element | Answer with the missing elements in the ordered span of ['nine hundred and thirty', 'nine hundred and thirty-one', 'nine hundred and thirty-five', 'nine hundred and thirty-four', 'nine hundred and thirty-eight', 'nine hundred and thirty-seven', 'nine hundred and thirty-six', 'nine hundred and thirty-two', 'nine hundred... | {} | {"element_list": ["nine hundred and thirty", "nine hundred and thirty-one", "nine hundred and thirty-five", "nine hundred and thirty-four", "nine hundred and thirty-eight", "nine hundred and thirty-seven", "nine hundred and thirty-six", "nine hundred and thirty-two", "nine hundred and thirty-three"], "missing_count": 0... | 1 | instruct |
table_statistics | Table:
- label: L3
P: L1
J: L3
S: L3
Z: L3
- label: L2
P: L2
J: L1
S: L3
Z: L2
- label: L2
P: L1
J: L1
S: L2
Z: L2
- label: L2
P: L2
J: L3
S: L2
Z: L3
- label: L3
P: L2
J: L3
S: L0
Z: L3
- label: L3
P: L1
J: L1
S: L0
Z: L0
- label: L1
P: L1
J: L1
S: L1
Z: L1
- lab... | Z | {"table": "- label: L3\n P: L1\n J: L3\n S: L3\n Z: L3\n- label: L2\n P: L2\n J: L1\n S: L3\n Z: L2\n- label: L2\n P: L1\n J: L1\n S: L2\n Z: L2\n- label: L2\n P: L2\n J: L3\n S: L2\n Z: L3\n- label: L3\n P: L2\n J: L3\n S: L0\n Z: L3\n- label: L3\n P: L1\n J: L1\n S: L0\n Z: L0\n- label: L1\n ... | 3 | instruct |
reference_tracking | Inventory:
- b1: green
- b2: yellow
- b3: yellow
- b4: blue
- b5: yellow
Initial State:
- b1 is in x4
- b2 is in x3
- b3 is in x4
- b4 is in x4
- b5 is in x2
Moves:
- Transfer b4 from x4 into x2.
- Relocate b1 from x4 to x2.
- Swap the balls in x3 and x4.
- Move b2 from x4 to x1.
- Move it from x1 to x2.
Where is b3 ... | x3 | {"family": "track", "balls": ["b1", "b2", "b3", "b4", "b5"], "boxes": ["x1", "x2", "x3", "x4"], "colors": {"b1": "green", "b2": "yellow", "b3": "yellow", "b4": "blue", "b5": "yellow"}, "initial_placement": {"b1": "x4", "b2": "x3", "b3": "x4", "b4": "x4", "b5": "x2"}, "moves": ["Transfer b4 from x4 into x2.", "Relocate ... | 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... | No | {"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,n5). edge(n1,n6). edge(n1,n7). edge(n2,n9). edge(n3,n8). edge(n3,n9). edge(n4,n9). edge(n5,n6). edge(n6,n7). edge(n7,n8). edge(n7,n9).\nleaf(n8). leaf(n9).\nval... | 3 | instruct |
logic_qa | Premise:
Alice is echo tagged.
Alice is alpha tagged.
Alice is lambda tagged.
Alice is gamma tagged.
David is lambda tagged.
If a person is echo tagged and alpha tagged, then that person is delta tagged.
For all x, if x is delta tagged and x is lambda tagged, then x is kappa tagged.
Every kappa-tagged person who is gam... | Alice | {"premise": ["Alice is echo tagged.", "Alice is alpha tagged.", "Alice is lambda tagged.", "Alice is gamma tagged.", "David is lambda tagged.", "If a person is echo tagged and alpha tagged, then that person is delta tagged.", "For all x, if x is delta tagged and x is lambda tagged, then x is kappa tagged.", "Every kapp... | 4 | 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": "add(add(N(1), N(-4)), env(-2, N(-8)))", "marked": false, "_time": 0.0004210472106933594, "_task": "attribute_grammar", "_level": 0, "_config": {"level": 0, "seed": null, "size": null, "depth": 3, "min_nodes": 3, "max_nodes": 7}, "_prompt_tokens": 235, "_answer_tokens": 2, "_cot_tokens": 0, ... | 0 | instruct |
most_probable_outcome | A container has 2 red items, 3 blue items, 6 green items, 7 gold items.
Draw 4 items in sequence.
After draw 1, replace the item before the next draw.
After draw 2, do not replace the item.
After draw 3, do not replace the item.
No draw result is observed in advance.
Which statement is more likely?
A: exactly 1 draws a... | B | {"problog": "", "english": "A container has 2 red items, 3 blue items, 6 green items, 7 gold items.\nDraw 4 items in sequence.\nAfter draw 1, replace the item before the next draw.\nAfter draw 2, do not replace the item.\nAfter draw 3, do not replace the item.\nNo draw result is observed in advance.\nWhich statement is... | 3 | instruct |
arithmetics | Evaluate 13 % bit_count(8) + -1.0 - min(0, (0)) + 5 - 11.7.
The answer is a number. | -7.7 | {"expr": "13 % bit_count(8) + -1.0 - min(0, (0)) + 5 - 11.7", "display_expr": "13 % bit_count(8) + -1.0 - min(0, (0)) + 5 - 11.7", "digit_mode": "normal", "semantics": "exact", "semantic_cue": false, "out_decimals": 6, "height": 8, "cot": "bit_count(8) = 1\n13 % 1 = 0\n0 + -1 = -1\nmin(0, 0) = 0\n-1 - 0 = -1\n-1 + 5 = ... | 3 | instruct |
multistep_evidence_retrieval | Premise:
[0] For all p, x, y, if p is a parent of x and p is a parent of y and x is different from y, then x is a sibling of y.
[1] If one person is a sibling of another, then the second is a sibling of the first.
[2] When one person is a parent of a second person and the second is an ancestor of a third person, the fi... | 2 5 7 10 15 16 | {"premise": ["For all p, x, y, if p is a parent of x and p is a parent of y and x is different from y, then x is a sibling of y.", "If one person is a sibling of another, then the second is a sibling of the first.", "When one person is a parent of a second person and the second is an ancestor of a third person, the fir... | 5 | instruct |
set_missing_element | Answer with the missing elements in the ordered span of ['2020-11-21', '2020-11-30', '2020-11-26', '2020-11-28', '2020-12-03', '2020-11-24', '2020-11-29', '2020-11-20', '2020-11-23', '2020-11-27', '2020-11-22', '2020-12-02', '2020-11-25', '2020-12-01'] as a Python set. | {} | {"element_list": ["2020-11-21", "2020-11-30", "2020-11-26", "2020-11-28", "2020-12-03", "2020-11-24", "2020-11-29", "2020-11-20", "2020-11-23", "2020-11-27", "2020-11-22", "2020-12-02", "2020-11-25", "2020-12-01"], "missing_count": 0, "_time": 0.00016832351684570312, "_task": "set_missing_element", "_level": 2, "_confi... | 2 | instruct |
analogical_case_matching | Which case can be embedded into Query? A case matches when every fact maps to a Query fact under one-to-one entity and relation renaming, with an optional consistent direction reversal for each relation. Query may contain additional facts. Answer with its ID.
M0: a alpha c, c alpha d, d alpha b, b beta d
M1: a alpha c... | M2 | {"cases": [{"id": "M0", "context": [["alpha", "a", "c"], ["alpha", "c", "d"], ["alpha", "d", "b"], ["beta", "b", "d"]], "consequence": ["alpha", "a", "b"]}, {"id": "M1", "context": [["alpha", "a", "c"], ["alpha", "d", "a"], ["beta", "b", "c"], ["beta", "d", "b"]], "consequence": ["alpha", "d", "b"]}, {"id": "M2", "cont... | 0 | instruct |
math_word_problem | A jar holds 7 cards. 2 cards removed; then multiplied by 4; then 20 more cards added; then cut to a fifth; then multiplied by 3. How many cards are in the jar now? Answer with a number. | 24 | {"family": "process", "unit": "cards", "base": 7, "observed": 24, "inverse": false, "steps": [["sub", 2], ["mul", 4], ["add", 20], ["div", 5], ["mul", 3]], "expr": "12*x/5 + 36/5", "equation": "Eq(12*x/5 + 36/5, 24)", "_time": 0.005919933319091797, "_task": "math_word_problem", "_level": 1, "_config": {"level": 1, "see... | 1 | instruct |
defeasible_nli | An `unless` condition must be shown to block its rule.
Facts:
Clara is alpha-tagged, foxtrot-tagged, charlie-tagged, and lambda-tagged.
Alice is alpha-tagged, delta-tagged, foxtrot-tagged, gamma-tagged, and lambda-tagged.
Farah is bravo-tagged and kappa-tagged.
Elena is gamma-tagged and bravo-tagged.
Clara is alpha-li... | Yes | {"premise": ["Clara is alpha tagged.", "Alice is alpha tagged.", "Alice is delta tagged.", "Clara is foxtrot tagged.", "Alice is foxtrot tagged.", "Alice is gamma tagged.", "Clara is alpha-linked to Alice.", "Alice is lambda tagged.", "Farah is bravo tagged.", "Clara is charlie tagged.", "Elena is gamma tagged.", "Clar... | 3 | instruct |
arithmetics | Evaluate max(-14, -3) / 3 + -4.9 + -3 % 12 // -3 + round(1 / -1 // (-11 % -7 - -10.8) // min((gcd(-7, 11) / 8), (4) + 1 + lcm(3, 8) * 6.2 + -11 / prime_count(32))) * (-2 / (is_prime(59))).
The answer is a number. | 7.1 | {"expr": "max(-14, -3) / 3 + -4.9 + -3 % 12 // -3 + round(1 / -1 // (-11 % -7 - -10.8) // min((gcd(-7, 11) / 8), (4) + 1 + lcm(3, 8) * 6.2 + -11 / prime_count(32))) * (-2 / (is_prime(59)))", "display_expr": "max(-14, -3) / 3 + -4.9 + -3 % 12 // -3 + round(1 / -1 // (-11 % -7 - -10.8) // min((gcd(-7, 11) / 8), (4) + 1 +... | 6 | instruct |
string_transduction | String: pixel quiet nova orbit winter
Operations:
- sort descending
- caesar shift by 26
- caesar shift by 3
- caesar shift by 1
- caesar shift by 25
Answer with the final string, excluding spaces. | azyxwwwuutsrrqqollllhhhed | {"mode": "program", "source": "pixel quiet nova orbit winter", "ops": ["sort descending", "caesar shift by 26", "caesar shift by 3", "caesar shift by 1", "caesar shift by 25"], "noop_rate": 0.2, "local_change_flags": [true, false, true, true, true], "effective_flags": [true, false, true, true, true], "effective_op_coun... | 3 | instruct |
qualitative_causal_reasoning | Assume linear causal relations, independent noise, and no exact cancellations.
X0 directly increases X10; X1 directly decreases X9; X11 directly decreases X2; X13 directly increases X0; X14 directly decreases X9; X3 directly increases X14; X3 directly increases X2; X3 directly decreases X4; X4 directly increases X14; ... | ambiguous | {"edges": [["X0", "X10", "+"], ["X1", "X9", "-"], ["X11", "X2", "-"], ["X13", "X0", "+"], ["X14", "X9", "-"], ["X3", "X14", "+"], ["X3", "X2", "+"], ["X3", "X4", "-"], ["X4", "X14", "+"], ["X4", "X2", "-"], ["X5", "X10", "-"], ["X7", "X5", "+"]], "nodes": ["X0", "X1", "X10", "X11", "X12", "X13", "X14", "X2", "X3", "X4"... | 1 | instruct |
planning | Initial true facts: cool(delta), dry(coral), dry(grove), free(grove), free(kestrel), ready(birch). All other facts are false.
Actions (preconditions -> effects; !fact means false):
guide(delta,kestrel): aligned(harbor),cool(delta),free(grove),!dry(fjord),!fixed(harbor),!free(delta),!open(coral) -> open(coral),!dry(cor... | close(kestrel,elm)
close(delta,fjord)
bind(amber,birch)
fasten(birch,linen)
lift(coral,delta)
release(fjord,grove)
guide(indigo,fjord)
fasten(elm,coral) | {"engine": "bounded-strips-v1", "horizon": 8, "style": "gray", "initial_true": ["cool(delta)", "dry(coral)", "dry(grove)", "free(grove)", "free(kestrel)", "ready(birch)"], "actions": [{"call": "guide(delta,kestrel)", "pre_true": ["aligned(harbor)", "cool(delta)", "free(grove)"], "pre_false": ["dry(fjord)", "fixed(harbo... | 5 | instruct |
controlled_code_execution | Predict the value returned by this Python call.
```python
def endpoint():
state = [-4, 1, -2, -5]
bias0 = 5
def f0(x, bias=bias0):
return x + bias + state[0]
bias0 += -7
state[1] = f0(state[1])
bias1 = 7
def f1(x):
return x + bias1 + state[1]
bias1 += 7
state[3] = f1(... | [-6, 0, -4, 11] | {"code": "def endpoint():\n state = [-4, 1, -2, -5]\n bias0 = 5\n def f0(x, bias=bias0):\n return x + bias + state[0]\n bias0 += -7\n state[1] = f0(state[1])\n bias1 = 7\n def f1(x):\n return x + bias1 + state[1]\n bias1 += 7\n state[3] = f1(state[3])\n alias2 = state\n al... | 4 | instruct |
belief_tracking | Initially, everyone knows that the map is in the drawer, the key is in the bowl, the ring is in the drawer, and the coin is in the case.
Story: Frank moves the coin to the tray. No one else sees the move. Grace sends Frank the message "I think the coin is in the case", but it is not delivered. Heidi moves the coin to ... | bowl | {"agents": ["Heidi", "Alice", "Carol", "Grace", "Frank", "Dave"], "objects": ["map", "key", "ring", "coin"], "containers": ["case", "drawer", "tray", "cabinet", "vase", "bowl"], "init": {"loc": {"map": "drawer", "key": "bowl", "ring": "drawer", "coin": "case"}}, "specs": [{"kind": "move", "actor": "Frank", "target": nu... | 4 | instruct |
process_inversion | Jar A starts with 2 marbles, jar B starts with 6 marbles. Then:
Step 1: 5 marbles were added to jar A.
Step 2: the count in jar A was tripled.
Step 3: 4 marbles were removed from jar B.
Step 4: some marbles were moved from jar A to jar B.
Step 5: 13 marbles were added to jar B.
Step 6: 14 marbles were moved from jar A ... | 7 | {"unit": "marbles", "names": "AB", "start": [2, 6], "steps": [["add", 0, 5], ["mul", 0, 3], ["sub", 1, 4], ["move", 0, 5, 1], ["add", 1, 13], ["move", 0, 14, 1]], "final": [2, 34], "hidden": ["step", 3], "q_step": 4, "q_jar": 1, "_time": 0.0002620220184326172, "_task": "process_inversion", "_level": 3, "_config": {"lev... | 3 | instruct |
code_runnability | Predict whether this Python call runs successfully or raises an exception.
```python
def endpoint(arg1, arg2):
seq12 = [arg1, (arg2 if arg1 <= arg1 else arg2) + fn6(arg1, arg2) if (arg2 >= -3 or 2 < -3) and 2 > arg1 else (arg2 + arg1) % (arg2 % (abs(arg1) + 1)), (recur9(abs(arg2) % 5, arg2) + (arg2 if arg2 == arg1 ... | ZeroDivisionError | {"code": "def endpoint(arg1, arg2):\n seq12 = [arg1, (arg2 if arg1 <= arg1 else arg2) + fn6(arg1, arg2) if (arg2 >= -3 or 2 < -3) and 2 > arg1 else (arg2 + arg1) % (arg2 % (abs(arg1) + 1)), (recur9(abs(arg2) % 5, arg2) + (arg2 if arg2 == arg1 else arg1)) // (abs(fn6(arg1 // arg1, arg1)) + 1)]\n acc13 = seq12.inde... | 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... | C | {"registers": ["r1", "r2", "r3", "r4", "r5"], "initial": {"r1": "A", "r2": "B", "r3": "C", "r4": "D", "r5": "E"}, "mappings": [{"X": "swap-first-two", "Y": "rotate-right", "Z": "swap-last-two"}, {"X": "swap-outer", "Y": "rotate-left", "Z": "rotate-right"}], "program": [{"kind": "op", "operation": 0}, {"kind": "op", "op... | 0 | instruct |
finite_automaton_execution | States:
states 0..12, start state 9, accepting states {3, 11}
Alphabet:
{a, b, c, d}
Transitions:
state 0: on a -> {7}; on b -> {5}; on c -> {6, 11}; on d -> {1, 5}
state 1: on a -> {11}; on b -> {6}; on c -> {3, 4, 6}; on d -> {0, 9}
state 2: on a -> {11}; on b -> {2, 3, 11}; on c -> {2, 6}; on d -> {10, 11}
state 3... | 7 | {"payload": {"states": "states 0..12, start state 9, accepting states {3, 11}", "alphabet": "{a, b, c, d}", "transitions": "state 0: on a -> {7}; on b -> {5}; on c -> {6, 11}; on d -> {1, 5}\nstate 1: on a -> {11}; on b -> {6}; on c -> {3, 4, 6}; on d -> {0, 9}\nstate 2: on a -> {11}; on b -> {2, 3, 11}; on c -> {2, 6}... | 4 | instruct |
qualitative_reasoning | There are 8 objects: E0, E1, E2, E3, E4, E5, E6, E7.
They have distinct ages.
Facts:
- E1 is the 4th-newest.
- E2 is newer than E4.
- E4 is newer than E1.
- E2 is immediately newer than E5.
Which object is the 3rd-newest?
The answer is one object label. | E4 | {"family": "ordinal", "n_entities": 8, "entities": ["E0", "E1", "E2", "E3", "E4", "E5", "E6", "E7"], "clues": [{"kind": "rank", "a": "E1", "rank": 3}, {"kind": "pair", "a": "E2", "b": "E4"}, {"kind": "pair", "a": "E4", "b": "E1"}, {"kind": "next", "a": "E2", "b": "E5"}], "clue_text": ["E1 is the 4th-newest.", "E2 is ne... | 3 | instruct |
finite_automaton_execution | States:
states 0..10, start state 4, accepting states {1, 3, 5, 6, 7, 9}
Alphabet:
{a, b, c}
Transitions:
state 0: on a -> {1, 6, 10}; on b -> {5}; on c -> {0, 1, 8}
state 1: on a -> {2, 9, 10}; on b -> {4, 5}; on c -> {0}
state 2: on a -> {8}; on b -> {0, 1, 9}; on c -> {8}
state 3: on a -> {6, 10}; on b -> {5, 7, 8... | 4 | {"payload": {"states": "states 0..10, start state 4, accepting states {1, 3, 5, 6, 7, 9}", "alphabet": "{a, b, c}", "transitions": "state 0: on a -> {1, 6, 10}; on b -> {5}; on c -> {0, 1, 8}\nstate 1: on a -> {2, 9, 10}; on b -> {4, 5}; on c -> {0}\nstate 2: on a -> {8}; on b -> {0, 1, 9}; on c -> {8}\nstate 3: on a -... | 3 | instruct |
metamath_core_select | Which option is sufficient to derive the conjecture?
Use only the listed premises and rules. No hidden background facts.
Rules may only rename variables, not substitute compound terms.
The answer is A, B, C, or D.
Premises:
1. P1(x, D1)
2. P2(y, F1(x, C1))
3. P2(x, F1(y, C1))
Rule Catalog:
- r1: P2(x, y) ==> P3(P1(x,... | C | {"premises": ["P1(x, D1)", "P2(y, F1(x, C1))", "P2(x, F1(y, C1))"], "raw_premises": [["|-", "A", "e.", "NN"], ["|-", "B", "=", "(", "A", "+", "1", ")"], ["|-", "A", "=", "(", "B", "+", "1", ")"]], "conjecture": "P2(F2(x, y), F2(y, x))", "raw_conjecture": ["|-", "(", "A", "x.", "B", ")", "=", "(", "B", "x.", "A", ")"], ... | 3 | instruct |
multistep_evidence_retrieval | Premise:
[0] Alice is delta-related to Elena.
[1] Anyone who is gamma tagged and foxtrot tagged is not echo tagged.
[2] Clara is alpha tagged.
[3] Clara is bravo tagged.
[4] Clara is delta tagged.
[5] David is alpha-linked to Clara.
[6] For all x, if x is bravo tagged and x is alpha tagged, then x is foxtrot tagged.
[7... | 1 2 3 4 6 8 | {"premise": ["Alice is delta-related to Elena.", "Anyone who is gamma tagged and foxtrot tagged is not echo tagged.", "Clara is alpha tagged.", "Clara is bravo tagged.", "Clara is delta tagged.", "David is alpha-linked to Clara.", "For all x, if x is bravo tagged and x is alpha tagged, then x is foxtrot tagged.", "From... | 1 | instruct |
code_runnability | Predict whether this Python call runs successfully or raises an exception.
```python
def endpoint(arg1):
seq5 = [arg1, -4, fn2(arg1 // (abs(2) + 1) if arg1 <= arg1 or arg1 >= arg1 else -3, fn2(-3 if arg1 >= arg1 else arg1, fn2(arg1, arg1))), arg1 // (fn2(arg1, arg1) * (arg1 if arg1 == arg1 else arg1)), (4 if arg1 >... | ZeroDivisionError | {"code": "def endpoint(arg1):\n seq5 = [arg1, -4, fn2(arg1 // (abs(2) + 1) if arg1 <= arg1 or arg1 >= arg1 else -3, fn2(-3 if arg1 >= arg1 else arg1, fn2(arg1, arg1))), arg1 // (fn2(arg1, arg1) * (arg1 if arg1 == arg1 else arg1)), (4 if arg1 > arg1 else fn2(2, arg1)) % (abs(arg1) + 1), ((3 if arg1 > 0 else arg1) if ... | 2 | instruct |
dynamic_programming | States: A B C D
Observations: 2 0 2 2 2 1 0
Start: A=2 B=-1 C=-4 D=0
Transitions (rows=from, columns=A B C D):
A: -2 -2 4 -2
B: 2 3 -1 -1
C: 4 3 -4 -4
D: 4 -2 4 4
Emissions (rows=state, columns=0..2):
A: -2 -3 -2
B: 2 -3 0
C: 2 -2 -4
D: 1 2 4
Score a state sequence by start + emissions + transitions. Find the maximum-s... | D D D D D D C | {"labels": ["A", "B", "C", "D"], "obs": [2, 0, 2, 2, 2, 1, 0], "start": [2, -1, -4, 0], "trans": [[-2, -2, 4, -2], [2, 3, -1, -1], [4, 3, -4, -4], [4, -2, 4, 4]], "emit": [[-2, -3, -2], [2, -3, 0], [2, -2, -4], [1, 2, 4]], "_time": 0.0003528594970703125, "_task": "dynamic_programming", "_level": 2, "_config": {"level":... | 2 | instruct |
table_statistics | Table:
group,C,S,J,M
G1,0.44,0.77,0.92,1.61
G0,0.62,1.91,0.17,-0.71
G0,-0.65,-1.31,-0.88,0.01
G1,0.13,1.8,1.8,1.24
G0,-0.7,-1.63,-0.05,-0.89
G1,1.39,1.6,1.41,1.67
G0,-0.03,-2.39,1.79,1.66
G0,1.85,0.0,-0.38,1.06
G0,-2.25,-0.44,0.34,-1.83
G1,1.34,1.44,0.05,1.54
G1,1.75,3.25,0.69,1.76
G1,0.81,3.84,0.97,0.37
Find:
column... | S | {"table": "group,C,S,J,M\nG1,0.44,0.77,0.92,1.61\nG0,0.62,1.91,0.17,-0.71\nG0,-0.65,-1.31,-0.88,0.01\nG1,0.13,1.8,1.8,1.24\nG0,-0.7,-1.63,-0.05,-0.89\nG1,1.39,1.6,1.41,1.67\nG0,-0.03,-2.39,1.79,1.66\nG0,1.85,0.0,-0.38,1.06\nG0,-2.25,-0.44,0.34,-1.83\nG1,1.34,1.44,0.05,1.54\nG1,1.75,3.25,0.69,1.76\nG1,0.81,3.84,0.97,0.3... | 0 | instruct |
multistep_abduction | Premise:
[0] david is trained.
[1] david is alert.
[2] bruno is trusted.
[3] clara is verified.
[4] david is active.
[5] alice helps farah.
[6] clara is active.
[7] Every trained entity that is also alert is careful.
[8] From x is careful, it follows that x is not approved.
Hypothesis:
bruno is approved.
Candidate Fa... | 0 3 | {"premise": ["david is trained.", "david is alert.", "bruno is trusted.", "clara is verified.", "david is active.", "alice helps farah.", "clara is active.", "Every trained entity that is also alert is careful.", "From x is careful, it follows that x is not approved."], "hypothesis": "bruno is approved.", "candidates":... | 2 | instruct |
systems_trace | A token bucket holds at most 4 tokens and starts with 1. At every time that is a multiple of 2 (time 2, 4, ...), 2 tokens are added, never going above 4; at a time with both a refill and a request, the refill comes first. A request is accepted if the bucket holds at least its cost, and then the cost is removed; otherwi... | 2 | {"system": "bucket", "prompt": "A token bucket holds at most 4 tokens and starts with 1. At every time that is a multiple of 2 (time 2, 4, ...), 2 tokens are added, never going above 4; at a time with both a refill and a request, the refill comes first. A request is accepted if the bucket holds at least its cost, and t... | 1 | instruct |
planning | Initial true facts: active(elm), linked(elm), linked(kestrel), ready(grove). All other facts are false.
Actions (preconditions -> effects; !fact means false):
drain(elm,grove): active(elm),charged(delta) -> clear(fjord),free(coral),!charged(delta)
lift(grove,indigo): active(elm),free(coral) -> closed(indigo),ready(har... | align(delta,coral)
drain(elm,grove)
lift(grove,indigo) | {"engine": "bounded-strips-v1", "horizon": 3, "style": "onehot", "initial_true": ["active(elm)", "linked(elm)", "linked(kestrel)", "ready(grove)"], "actions": [{"call": "drain(elm,grove)", "pre_true": ["active(elm)", "charged(delta)"], "pre_false": [], "add": ["clear(fjord)", "free(coral)"], "delete": ["charged(delta)"... | 0 | instruct |
planar_geometry_relations | Given points: A=(37/5, 169/5); C=(1, -7/2); F=(-124/15, 229/30); J=(12, -1); K=(-14, -1); L=(-261/10, 243/10); M=(-11, -11); O=(-122/5, 389/20); P=(-3, 13); Q=(13, 4); R=(-3/5, 163/10); S=(-224/15, 89/30); V=(-18/5, 99/5); W=(-1, 11); X=(2, 4); Y=(-23/5, 123/10); Z=(-13/10, 163/20).
Question: What is the intersection p... | (-58/5, 53/10) | {"points": {"A": "(37/5, 169/5)", "C": "(1, -7/2)", "F": "(-124/15, 229/30)", "J": "(12, -1)", "K": "(-14, -1)", "L": "(-261/10, 243/10)", "M": "(-11, -11)", "O": "(-122/5, 389/20)", "P": "(-3, 13)", "Q": "(13, 4)", "R": "(-3/5, 163/10)", "S": "(-224/15, 89/30)", "V": "(-18/5, 99/5)", "W": "(-1, 11)", "X": "(2, 4)", "Y... | 6 | instruct |
qualitative_reasoning | There are 9 entities labeled 0 through 8.
Read 'i rel j' as 'entity i is rel to entity j'.
Facts:
- 3 equals 0
- 7 overlaps 0
- 6 before 3
- 5 equals 3
- 8 overlapped-by 7
- 1 overlapped-by 7
- 2 before 1
- 4 meets 5
- 1 equals 8
- 0 after 6
- 0 finished-by 8
- 6 starts 7
- 2 before 5
- 1 after 6
- 2 before 8
- 3 finis... | after | {"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": 9, "hops": 6, "n_revealed": 35, "entities": [[-2, 0, 0, 3], [-2, -1, 1, 3], [-3, 2, -3, -2], [-2, 3, 0, 3], [-2, -1, -1, 0], [-1, 2, 0, 3], [0, 2, -3, -2], [-3,... | 4 | instruct |
code_analysis | Program:
```python
import random
y, status, level = 0, 'busy', 0
def step():
global y, status, level
if y >= 1:
match y:
case 1:
level, y = max(level - 1, 0), (y + level + 1) % 2
case 0:
y = (y + 1) % 2
case _:
status ... | Yes | {"program": "import random\n\ny, status, level = 0, 'busy', 0\n\ndef step():\n global y, status, level\n if y >= 1:\n match y:\n case 1:\n level, y = max(level - 1, 0), (y + level + 1) % 2\n case 0:\n y = (y + 1) % 2\n case _:\n ... | 2 | instruct |
shift_reduce_parsing | Rules:
R0: N0 -> e
R1: N1 -> d
R2: N2 -> N0 N0 N1
R3: N3 -> a
R4: N4 -> N2 N1
Input: e e d d
Shift tokens left to right. After every shift, repeatedly reduce the longest stack suffix matching a rule RHS; ties use the lowest rule number.
What is the stack after consuming 3 tokens? The answer is the stack symbols from bo... | N2 | {"rules": [["N0", ["e"]], ["N1", ["d"]], ["N2", ["N0", "N0", "N1"]], ["N3", ["a"]], ["N4", ["N2", "N1"]]], "tokens": ["e", "e", "d", "d"], "k": 3, "_time": 0.00020623207092285156, "_task": "shift_reduce_parsing", "_level": 1, "_config": {"level": 1, "seed": null, "size": null, "n_rules": 5, "derivation_depth": 7, "quer... | 1 | instruct |
finite_automaton_execution | States:
states 0..12, start state 1, accepting states {1, 2, 7, 9, 10, 11}
Alphabet:
{a, b, c, d}
Transitions:
state 0: on a -> {7}; on b -> {5, 8, 12}; on c -> {5}; on d -> {2, 6, 12}
state 1: on a -> {6}; on b -> {5, 7, 10}; on c -> {0, 3, 6}; on d -> {3, 10, 12}
state 2: on a -> {3, 6}; on b -> {4, 8}; on c -> {11... | 11 | {"payload": {"states": "states 0..12, start state 1, accepting states {1, 2, 7, 9, 10, 11}", "alphabet": "{a, b, c, d}", "transitions": "state 0: on a -> {7}; on b -> {5, 8, 12}; on c -> {5}; on d -> {2, 6, 12}\nstate 1: on a -> {6}; on b -> {5, 7, 10}; on c -> {0, 3, 6}; on d -> {3, 10, 12}\nstate 2: on a -> {3, 6}; o... | 4 | instruct |
syntax_error_detection | (START)
start
(GRAMMAR)
start ::= root
there ::= 'there'
det_pl_indef ::= 'some'
conj ::= 'yet'
root ::= decl '.'
decl_simple ::= there are det_pl_indef n_thing_pl
are ::= 'are'
det_pl_indef ::= 'many'
decl ::= decl_simple ',' conj decl_simple
n_thing_pl ::= 'messages'
(STRING)
there are many messages , yet there
An... | INCOMPLETE | {"g": "start ::= root\nthere ::= 'there'\ndet_pl_indef ::= 'some'\nconj ::= 'yet'\nroot ::= decl '.'\ndecl_simple ::= there are det_pl_indef n_thing_pl\nare ::= 'are'\ndet_pl_indef ::= 'many'\ndecl ::= decl_simple ',' conj decl_simple\nn_thing_pl ::= 'messages'", "start": "start", "tokens": ["there", "are", "many", "me... | 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: 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(n0,n8). edge(n1,n4). edge(n1,n5). edge(n1,n7). edge(n2,n6). edge(n2,n9). edge(n3,n7). edge(n3,n9). edge(n4,n7). edge(n4,n8). edge(n4,n9).... | 3 | instruct |
function_manipulation | Define $h(x)=\left(\int_{1}^{x}\left(\left(\left(t_{1}\right)+\left(\left(t_{1}-1\right)\right)\right)\left(1 + \left(t_{1}-1\right)\right)\right)\,dt_{1}\right)-\left(\frac{1}{3}\left(x-1\right)\right)$.
Compute $h'(1)$.
The answer is a reduced rational number. | 2/3 | {"definitions": [], "expression": {"op": "sub", "args": [{"op": "integrate", "args": [{"op": "mul", "args": [{"op": "add", "args": [{"op": "var"}, {"op": "poly", "coeffs": ["0", "1"], "center": "1"}]}, {"op": "poly", "coeffs": ["1", "1"], "center": "1"}]}]}, {"op": "poly", "coeffs": ["0", "1/3"], "center": "1"}]}, "lat... | 1 | instruct |
set_missing_element | Answer with the missing elements in the ordered span of ['nine hundred and forty-seven', 'nine hundred and fifty-three', 'nine hundred and fifty-four', 'nine hundred and fifty-one', 'nine hundred and fifty-five', 'nine hundred and fifty', 'nine hundred and forty-eight', 'nine hundred and forty-nine', 'nine hundred and ... | {} | {"element_list": ["nine hundred and forty-seven", "nine hundred and fifty-three", "nine hundred and fifty-four", "nine hundred and fifty-one", "nine hundred and fifty-five", "nine hundred and fifty", "nine hundred and forty-eight", "nine hundred and forty-nine", "nine hundred and fifty-two"], "missing_count": 0, "_time... | 1 | instruct |
systems_trace | Two-phase commit with a coordinator and participants P1, P2, P3. The coordinator asks each participant to vote: P1 votes yes; P2 votes yes; P3 votes yes. The coordinator decides commit only if every participant votes yes; otherwise it decides abort (a missing vote counts as no). The coordinator sends its decision to ev... | P1:C P2:C P3:C | {"system": "commit", "prompt": "Two-phase commit with a coordinator and participants P1, P2, P3. The coordinator asks each participant to vote: P1 votes yes; P2 votes yes; P3 votes yes. The coordinator decides commit only if every participant votes yes; otherwise it decides abort (a missing vote counts as no). The coor... | 0 | instruct |
set_expression | C = ['three hundred and twenty-five', 'one hundred and fifty-one', 'one hundred and sixty-one', 'three hundred and thirty-eight', 'one hundred and seventy', 'two hundred and fifty-four', 'two hundred and six', 'three hundred and thirty', 'one hundred and seventy-one', 'sixty-nine', 'one hundred', 'thirty-seven', 'two h... | 2 | {"expr": "C.count('three hundred and fifty-four')", "list_mode": true, "C": ["three hundred and twenty-five", "one hundred and fifty-one", "one hundred and sixty-one", "three hundred and thirty-eight", "one hundred and seventy", "two hundred and fifty-four", "two hundred and six", "three hundred and thirty", "one hundr... | 6 | instruct |
set_missing_element | Answer with the missing elements in the ordered span of [694, 690, 693, 689] as a Python set. | {691, 692} | {"element_list": [694, 690, 693, 689], "missing_count": 2, "_time": 0.00013875961303710938, "_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": 27, "_answer_tokens": 6, "_cot_tokens... | 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: ((((b (((\v0.v0) c) ((\v0.v0) d))) (\v0.((a a) (d v0)))) ((\v0.(\v1.(\v1.(v0 ((\v3.d) v1))))) v1)) (\v0.(((\v0.((\v2.c) a)) (\v1.(v1 v0))) (\v1.(\v2.(... | ((((b (c d)) (\x0.((a a) (d x0)))) (\x1.(\x2.(v1 d)))) (\x3.(c (\x4.(\x5.(x4 d)))))) | {"term": "((((b (((\\v0.v0) c) ((\\v0.v0) d))) (\\v0.((a a) (d v0)))) ((\\v0.(\\v1.(\\v1.(v0 ((\\v3.d) v1))))) v1)) (\\v0.(((\\v0.((\\v2.c) a)) (\\v1.(v1 v0))) (\\v1.(\\v2.(v1 d))))))", "normal_form": "((((b (c d)) (\\x0.((a a) (d x0)))) (\\x1.(\\x2.(v1 d)))) (\\x3.(c (\\x4.(\\x5.(x4 d))))))", "beta_steps": 6, "has_sha... | 1 | instruct |
qualitative_causal_reasoning | Assume linear causal relations, independent noise, and no exact cancellations.
X10 directly decreases X3; X10 directly decreases X7; X2 directly increases X3; X2 directly increases X9; X4 directly increases X3; X7 directly decreases X3; X8 directly decreases X5; X9 directly increases X7.
Given X9, are X2 and X7 assoc... | independent | {"edges": [["X10", "X3", "-"], ["X10", "X7", "-"], ["X2", "X3", "+"], ["X2", "X9", "+"], ["X4", "X3", "+"], ["X7", "X3", "-"], ["X8", "X5", "-"], ["X9", "X7", "+"]], "nodes": ["X0", "X1", "X10", "X2", "X3", "X4", "X5", "X6", "X7", "X8", "X9"], "query": {"kind": "conditional_association", "source": "X2", "target": "X7",... | 0 | instruct |
set_expression | A = {21, 12, 22, 13, 16, 31}
C = {21, 12, 22, 13, 7, 31}
Evaluate len((A - (A - C))). | 5 | {"expr": "len((A - (A - C)))", "list_mode": false, "A": [21, 12, 22, 13, 16, 31], "C": [21, 12, 22, 13, 7, 31], "_time": 0.00018358230590820312, "_task": "set_expression", "_level": 0, "_config": {"level": 0, "seed": null, "size": null, "domain_size": 32, "set_size": 6, "n_domains": 2, "min_depth": 1, "max_depth": 2, "... | 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:
- r(x4, x6, x5) = r(x4, x6, h(x7, b))
- h(x5, p(x9, x9)) = h(x2, p(x9, b))
- h(x... | Yes | {"answer": "Yes", "equations": ["r(x4, x6, x5) = r(x4, x6, h(x7, b))", "h(x5, p(x9, x9)) = h(x2, p(x9, b))", "h(x9, b) = h(x0, b)", "x4 = x8", "h(b, x3) = h(x0, x0)", "h(b, x1) = h(x0, x0)", "r(b, b, x3) = r(b, b, b)"], "candidate": "h(x0, b) = h(x1, b)", "num_equations": 7, "num_variables": 10, "num_bindings_in_mgu": ... | 2 | instruct |
table_qa | Execute this SQL query on the table named dataframe:
Table 1:
\begin{tabular}{l}
\hline
qty \\
\hline
2.00 \\
3.00 \\
4.00 \\
5.00 \\
6.00 \\
7.00 \\
8.00 \\
9.00 \\
10.00 \\
11.00 \\
\hline
\end{tabular}
In this table, — represents SQL NULL.
SQL: SELECT ROUND(SUM("qty"), 2) FROM dataframe WHERE... | 65.0 | {"table": "\\begin{tabular}{l}\n\\hline\n qty \\\\\n\\hline\n 2.00 \\\\\n 3.00 \\\\\n 4.00 \\\\\n 5.00 \\\\\n 6.00 \\\\\n 7.00 \\\\\n 8.00 \\\\\n 9.00 \\\\\n 10.00 \\\\\n 11.00 \\\\\n\\hline\n\\end{tabular}", "tables": ["\\begin{tabular}{l}\n\\hline\n qty \\\\\n\\hline\n 2.00 \\\\\n 3.00 \\\\\n 4.00 \\\\... | 0 | instruct |
belief_tracking | Initially, everyone knows that the note is in the vase.
Story: Dave moves the note to the chest. No one else sees the move. Dave moves the note to the bin. Unknown to the others, Alice watches through a window. Dave moves the note to the chest. Unknown to the others, Alice watches through a window. Dave moves the note... | bowl | {"agents": ["Grace", "Dave", "Alice", "Heidi"], "objects": ["note"], "containers": ["vase", "bin", "chest", "bowl"], "init": {"loc": {"note": "vase"}}, "specs": [{"kind": "move", "actor": "Dave", "target": null, "policy": null, "report_type": null, "scene": "private_observation", "object": "note", "destination": "chest... | 0 | instruct |
grid_navigation | Grid [0,5]x[0,5], N=+y, E=+x.
Initial Facts:
- B is right of A.
- A starts at (1, 5).
- D is in the same column as A.
- B is below A.
- D is in the same row as B.
- C is below D.
- A is above C.
- B is right of D.
Steps:
1. C jumps to B's position offset by (0, 1).
2. A jumps to D's position offset by (1, 0).
What is... | 1 | {"answer_type": "distance", "query_a": "B", "query_b": "C", "grid": 5, "objects": ["A", "B", "C", "D"], "facts": [{"k": "h", "a": "B", "b": "A", "r": "right"}, {"k": "coord", "a": "A", "p": [1, 5]}, {"k": "h", "a": "D", "b": "A", "r": "aligned"}, {"k": "v", "a": "B", "b": "A", "r": "below"}, {"k": "v", "a": "D", "b": "... | 1 | instruct |
math_word_problem | Tara has as many books as Mei and Omar combined. Carlos has as many books as Omar and Tara combined. Mei has 2 times as many books as Omar. Carlos has 288 books. How many books does Tara have? Answer with a number. | 216 | {"family": "relational", "unit": "books", "names": ["Omar", "Mei", "Tara", "Carlos"], "relations": [["combine", "Tara", "Mei", null, "Omar"], ["combine", "Carlos", "Omar", null, "Tara"], ["times", "Mei", "Omar", 2, null]], "given": "Carlos", "asked": "Tara", "given_value": 288, "values": {"Omar": 72, "Mei": 144, "Tara"... | 6 | instruct |
code_analysis | Program:
```python
import random
phase, color, locked = 'fail', 'blue', True
def step():
global phase, color, locked
phase = random.choice(['fail', 'wait', 'done', 'idle', 'retry'])
if (phase != 'retry') or (locked):
color, phase = {'blue': 'amber', 'white': 'blue', 'green': 'white', 'red': 'green... | [('fail', 'blue', True), ('idle', 'amber', True), ('idle', 'red', True), ('idle', 'green', True), ('idle', 'white', True)] | {"program": "import random\n\nphase, color, locked = 'fail', 'blue', True\n\ndef step():\n global phase, color, locked\n phase = random.choice(['fail', 'wait', 'done', 'idle', 'retry'])\n if (phase != 'retry') or (locked):\n color, phase = {'blue': 'amber', 'white': 'blue', 'green': 'white', 'red': 'gre... | 5 | instruct |
parsing_derivation | (START)
start
(GRAMMAR)
R0: expr -> '⟨' seq '⟩'
R1: expr -> '<' seq '>'
R2: expr -> '⟦' seq '⟧'
R3: expr -> '(' seq ')'
R4: seq ->
R5: expr -> '⟪' seq '⟫'
R6: seq -> expr seq
R7: start -> seq
R8: expr -> '[' seq ']'
(STRING)
< ⟪ [ ] ⟫ > [ ] < > ⟨ ⟩ < >
(QUESTION)
The answer is the rule labels used in the leftmost d... | R7 R6 R1 R6 R5 R6 R8 R4 R4 R4 R6 R8 R4 R6 R1 R4 R6 R0 R4 R6 R1 R4 R4 | {"label": "unambiguous", "tokens": ["<", "\u27ea", "[", "]", "\u27eb", ">", "[", "]", "<", ">", "\u27e8", "\u27e9", "<", ">"], "g": "start -> seq\nexpr -> '\u27ea' seq '\u27eb'\nexpr -> '<' seq '>'\nexpr -> '(' seq ')'\nseq -> \nseq -> expr seq\nexpr -> '\u27e8' seq '\u27e9'\nexpr -> '[' seq ']'\nexpr -> '\u27e6' seq '... | 2 | instruct |
coreference | Each lineup contains the same introduced people exactly once. A reordering lists the source positions from left to right. Each description occurrence is independent, and later statements may resolve earlier ones.
(1) a tall young quiet kind teacher named Mary, a short young quiet kind teacher named Adam, a tall old qu... | Mary | {"sentences": "(1) a tall young quiet kind teacher named Mary, a short young quiet kind teacher named Adam, a tall old quiet kind teacher named Anna, and a short old quiet kind teacher named Lily formed a lineup in that order.\n(2) The lineup from sentence 1 was reordered using positions 4, 2, 1, 3, in that order.\n(3)... | 1 | instruct |
parsing_derivation | (START)
start
(GRAMMAR)
R0: start -> seq
R1: expr -> '<' seq '>'
R2: seq ->
R3: seq -> expr 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. | R0 R3 R4 R2 R3 R4 R2 R3 R4 R2 R2 | {"label": "unambiguous", "tokens": ["(", ")", "(", ")", "(", ")"], "g": "expr -> '<' seq '>'\nexpr -> '(' seq ')'\nexpr -> '[' seq ']'\nseq -> \nseq -> expr seq\nstart -> seq", "start": "start", "labeled_g": "R0: start -> seq\nR1: expr -> '<' seq '>'\nR2: seq -> \nR3: seq -> expr seq\nR4: expr -> '(' seq ')'\nR5: expr ... | 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, or None.
M0: d alpha e, f beta e, a gamma c, a gamma g, c g... | M4 | {"cases": [{"id": "M0", "context": [["alpha", "d", "e"], ["beta", "f", "e"], ["gamma", "a", "c"], ["gamma", "a", "g"], ["gamma", "c", "f"], ["gamma", "d", "f"], ["gamma", "g", "b"]], "consequence": ["gamma", "c", "e"]}, {"id": "M1", "context": [["alpha", "a", "g"], ["beta", "f", "a"], ["gamma", "b", "f"], ["gamma", "b"... | 5 | instruct |
sequential_induction | Infer U[n]. Max recurrence degree: 0. Ops: +, -, *.
Use n. Give the simplified polynomial RHS.
Sequence: [27, 0, -27, -54, -81, -108, -135, -162, -189, -216, -243, -270]
The answer is the RHS only. | -27 * n + 27 | {"first elements": [27, 0, -27, -54, -81, -108, -135, -162, -189, -216, -243, -270], "degree of recursion": 0, "initial terms": [], "canonical cost": 7, "canonical max cost": 7, "_time": 0.002245187759399414, "_task": "sequential_induction", "_level": 2, "_config": {"level": 2, "seed": null, "size": null, "mode": "simp... | 2 | instruct |
set_missing_element | Answer with the missing elements in the ordered span of [213, 208, 212, 210, 207, 215] as a Python set. | {209, 211, 214} | {"element_list": [213, 208, 212, 210, 207, 215], "missing_count": 3, "_time": 0.00012922286987304688, "_task": "set_missing_element", "_level": 1, "_config": {"level": 1, "seed": null, "size": null, "domain_size": 300, "set_size": 9, "n_domains": 3, "prob_no_missing": 0.1}, "_prompt_tokens": 33, "_answer_tokens": 9, "_... | 1 | instruct |
multistep_evidence_retrieval | Premise:
[0] If one person is a parent of a second person, and the second is an ancestor of a third person, then the first is an ancestor of the third.
[1] Whenever x is a parent of y, x is an ancestor of y.
[2] alice is a parent of clara.
[3] alice is adult.
[4] david is a parent of alice.
Hypothesis:
david is not an... | 0 1 2 4 | {"premise": ["If one person is a parent of a second person, and the second is an ancestor of a third person, then the first is an ancestor of the third.", "Whenever x is a parent of y, x is an ancestor of y.", "alice is a parent of clara.", "alice is adult.", "david is a parent of alice."], "hypothesis": "david is not ... | 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: d alpha b, f alpha d, c beta b, d gamma b, e gamma c
M1... | M2 | {"cases": [{"id": "M0", "context": [["alpha", "d", "b"], ["alpha", "f", "d"], ["beta", "c", "b"], ["gamma", "d", "b"], ["gamma", "e", "c"]], "consequence": ["alpha", "c", "b"]}, {"id": "M1", "context": [["alpha", "f", "a"], ["beta", "c", "d"], ["beta", "e", "c"], ["gamma", "b", "d"], ["gamma", "c", "a"]], "consequence"... | 1 | instruct |
systems_trace | A cache holds at most 3 keys and starts empty. On an access, a key already in the cache is a hit; otherwise it is a miss and the key is inserted, and if the cache is full you first evict the resident key that was inserted earliest (FIFO). Accesses, in order: 1 3 1 0 2 1 3 1 0 3 1 1.
List the evicted keys in the order t... | 1 3 0 2 | {"system": "cache", "prompt": "A cache holds at most 3 keys and starts empty. On an access, a key already in the cache is a hit; otherwise it is a miss and the key is inserted, and if the cache is full you first evict the resident key that was inserted earliest (FIFO). Accesses, in order: 1 3 1 0 2 1 3 1 0 3 1 1.\nList... | 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... | H | {"registers": ["r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8"], "initial": {"r1": "A", "r2": "B", "r3": "C", "r4": "D", "r5": "E", "r6": "F", "r7": "G", "r8": "H"}, "mappings": [{"X": "swap-last-two", "Y": "swap-first-two", "Z": "rotate-left"}, {"X": "rotate-left", "Y": "swap-last-two", "Z": "swap-first-two"}, {"X": "s... | 5 | instruct |
constrained_continuation | Complete <HOLE> according to the grammar.
GRAMMAR:
C ::= 'give'
B ::= B 'give'
B ::= '[' B ']'
S ::= A
A ::= B
B ::= C
SENTENCE:
[ <HOLE> ] ]
Return only the missing 3 tokens. | [ give give | {"g": "C ::= 'give'\nB ::= B 'give'\nB ::= '[' B ']'\nS ::= A\nA ::= B\nB ::= C", "start": "S", "k": 3, "prefix": ["["], "suffix": ["]", "]"], "sentence": "[ <HOLE> ] ]", "n_candidates": 1, "n_reachable": 7, "finite_space_exhaustively_checked": true, "_time": 0.006814718246459961, "_task": "constrained_continuation", "... | 0 | instruct |
code_analysis | Program:
```python
import random
mode, flag = 'idle', False
def step():
global mode, flag
if mode == 'idle':
mode, flag = 'done' if (flag) or (flag) else mode, flag if not flag else not flag
mode = random.choice(['idle', 'wait', 'done'])
```
Start from the assignments above; each transition call... | [('idle', False)] | {"program": "import random\n\nmode, flag = 'idle', False\n\ndef step():\n global mode, flag\n if mode == 'idle':\n mode, flag = 'done' if (flag) or (flag) else mode, flag if not flag else not flag\n mode = random.choice(['idle', 'wait', 'done'])\n", "predicates": "p0 := mode == 'idle'\np1 := mode == 'wa... | 0 | instruct |
inverse_math | Claim: f = 9*x^2 - 54*x + 153/2 satisfies f >= -4 for all real x.
Prove or refute it. If true, answer 'proof: ' followed by f - (-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. 'counterexample: x = 1'.
Use plain notatio... | counterexample: x = 3 | {"mode": "claim", "f": "9*x^2 - 54*x + 153/2", "bound": "-4", "vars": ["x"], "_time": 0.011653900146484375, "_task": "inverse_math", "_level": 1, "_config": {"level": 1, "seed": null, "size": 1.8}, "_prompt_tokens": 117, "_answer_tokens": 7, "_cot_tokens": 0, "_generator_name": "reasoning_core", "_generator_version": "... | 1 | instruct |
multistep_nli | Premise:
Clara is beta-linked to Alice.
Alice is alpha tagged.
Alice is delta tagged.
Elena is not gamma-linked to Bruno.
If a person is beta-linked to someone alpha tagged, then that person is bravo tagged.
If a person is bravo tagged, then that person is foxtrot tagged.
Every bravo-tagged person who is delta tagged i... | No | {"premise": ["Clara is beta-linked to Alice.", "Alice is alpha tagged.", "Alice is delta tagged.", "Elena is not gamma-linked to Bruno.", "If a person is beta-linked to someone alpha tagged, then that person is bravo tagged.", "If a person is bravo tagged, then that person is foxtrot tagged.", "Every bravo-tagged perso... | 1 | instruct |
graph_pathfinding | Find the shortest directed path from node 7 to node 8. Return space-separated nodes, or `None` if no path exists.
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, 0, 0, 1]
[1, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, ... | 7 5 2 1 0 8 | {"weighted": false, "mention_no_path": true, "mention_ties": false, "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, 0, 0, 1]\n[1, 0, 0, 0, 0, 0, 0, 0, 0]\n[0, 1, 0, 0, 0, 0, 0, 0, 0]\n[0, 0, 0, 0, 1, 0, 0, 0, 0]\n[0, 0, 0, 0... | 1 | instruct |
table_qa | Execute this SQL query on the table named dataframe:
Table 1:
qty,customer
2,C002
3,C002
4,C001
5,C003
6,C003
7,C002
8,C002
9,C003
In this table, — represents SQL NULL.
SQL: SELECT COUNT(*) FROM dataframe WHERE TRUE
The answer is the result as a single number without display formatting. | 8 | {"table": "qty,customer\n2,C002\n3,C002\n4,C001\n5,C003\n6,C003\n7,C002\n8,C002\n9,C003\n", "tables": ["qty,customer\n2,C002\n3,C002\n4,C001\n5,C003\n6,C003\n7,C002\n8,C002\n9,C003\n"], "query": "SELECT COUNT(*) FROM dataframe WHERE TRUE", "query_spec": {"query_conditioned": true, "plan": {"predicates": [], "projection... | 0 | instruct |
parsing_derivation | (START)
start
(GRAMMAR)
R0: pro_pl_agent -> 'they'
R1: name -> 'Alice'
R2: vp_agent_base -> v_person_trans_base np_person_obj
R3: root -> question '?'
R4: np_person_obj -> name
R5: start -> root
R6: np_pl_agent -> pro_pl_agent
R7: name -> 'Bob'
R8: do -> 'do'
R9: question -> do np_pl_agent vp_agent_base
R10: v_person_... | R5 R3 R9 R8 R6 R0 R2 R10 R4 R1 | {"label": "unambiguous", "tokens": ["do", "they", "meet", "Alice", "?"], "g": "name -> 'Alice'\nquestion -> do np_pl_agent vp_agent_base\nstart -> root\nv_person_trans_base -> 'meet'\nname -> 'Bob'\nnp_person_obj -> name\nroot -> question '?'\nvp_agent_base -> v_person_trans_base np_person_obj\nnp_pl_agent -> pro_pl_ag... | 3 | instruct |
syntax_error_detection | (START)
start
(GRAMMAR)
root -> decl '.'
det_sg_a -> 'a'
decl -> decl_simple
n_sg_c -> 'friend'
start -> root
is -> 'is'
decl_simple -> there is det_sg_a n_sg_c
there -> 'there'
(STRING)
there there is a friend .
Answer OK, INCOMPLETE, or ERROR token for the first invalid token. If that token repeats in STRING, appe... | ERROR there@2 | {"g": "root -> decl '.'\ndet_sg_a -> 'a'\ndecl -> decl_simple\nn_sg_c -> 'friend'\nstart -> root\nis -> 'is'\ndecl_simple -> there is det_sg_a n_sg_c\nthere -> 'there'", "start": "start", "tokens": ["there", "there", "is", "a", "friend", "."], "error_index": 1, "_time": 0.1681506633758545, "_task": "syntax_error_detect... | 5 | instruct |
belief_tracking | Initially, everyone knows that the coin is in the bowl.
Story: Dave moves the coin to the bowl. No one else sees the move. Carol moves the coin to the bowl. Unknown to the others, Bob watches through a window. Carol moves the coin to the box. Unknown to the others, Bob watches through a window. Carol moves the coin to... | bowl | {"agents": ["Carol", "Dave", "Heidi", "Bob"], "objects": ["coin"], "containers": ["box", "bowl", "case"], "init": {"loc": {"coin": "bowl"}}, "specs": [{"kind": "move", "actor": "Dave", "target": null, "policy": null, "report_type": null, "scene": "private_observation", "object": "coin", "destination": "bowl", "observer... | 1 | instruct |
systems_trace | A cache holds at most 3 keys and starts empty. On an access, a key already in the cache is a hit; otherwise it is a miss and the key is inserted, and if the cache is full you first evict the resident key that was inserted earliest (FIFO). Accesses, in order: 1 1 1 4 4 3 2 4.
Which keys are in the cache at the end? List... | 2 3 4 | {"system": "cache", "prompt": "A cache holds at most 3 keys and starts empty. On an access, a key already in the cache is a hit; otherwise it is a miss and the key is inserted, and if the cache is full you first evict the resident key that was inserted earliest (FIFO). Accesses, in order: 1 1 1 4 4 3 2 4.\nWhich keys a... | 0 | instruct |
function_manipulation | Let $f(x)=\frac{1}{2} - 2\left(x-1\right)$.
Define $h(x)=\int_{1}^{x}\left(\left(f\left(\left(t_{1}\right)\left(1 + \frac{1}{2}\left(t_{1}-1\right)\right)\right)\right)\left(1 + \left(t_{1}-1\right)\right)\right)\,dt_{1}$.
Compute $h'(1)$.
The answer is a reduced rational number. | 1/2 | {"definitions": [{"name": "f", "kind": "explicit", "input_center": "1", "output_center": "1/2", "coeffs": ["1/2", "-2"]}], "expression": {"op": "integrate", "args": [{"op": "mul", "args": [{"op": "call", "args": [{"op": "mul", "args": [{"op": "var"}, {"op": "poly", "coeffs": ["1", "1/2"], "center": "1"}]}], "name": "f"... | 1 | instruct |
table_qa | Execute this SQL query on the table named dataframe:
Table 1:
country: Spain; category: Clothing; row_id: R0000
country: Spain; category: Clothing; row_id: R0000
country: Italy; category: Electronics; row_id: R0002
country: Germany; category: Books; row_id: R0003
country: Germany; category: Books; row_id: R0004
countr... | Clothing,R0000 | {"table": "country: Spain; category: Clothing; row_id: R0000\ncountry: Spain; category: Clothing; row_id: R0000\ncountry: Italy; category: Electronics; row_id: R0002\ncountry: Germany; category: Books; row_id: R0003\ncountry: Germany; category: Books; row_id: R0004\ncountry: Germany; category: Food; row_id: R0005\ncoun... | 0 | instruct |
code_runnability | Predict whether this Python call runs successfully or raises an exception.
```python
def recur8(n9, z10):
if n9 <= 0:
return z10
return recur8(n9 - 1, z10 + n9)
def fn2(p3, p4):
return p3
def endpoint(arg1):
seq11 = [arg1, arg1 + recur8(abs(arg1) % 5, arg1), fn5(recur8(abs(arg1) % 5, arg1) if ... | OK | {"code": "def recur8(n9, z10):\n if n9 <= 0:\n return z10\n return recur8(n9 - 1, z10 + n9)\n\ndef fn2(p3, p4):\n return p3\n\ndef endpoint(arg1):\n seq11 = [arg1, arg1 + recur8(abs(arg1) % 5, arg1), fn5(recur8(abs(arg1) % 5, arg1) if arg1 == -3 else arg1 * arg1, recur8(abs(2) % 5, fn5(arg1, arg1))),... | 4 | instruct |
defeasible_nli | An `unless` condition must be shown to block its rule.
Facts:
Clara is alpha-tagged and foxtrot-tagged.
Elena is alpha-tagged, bravo-tagged, foxtrot-tagged, gamma-tagged, lambda-tagged, and not charlie-tagged.
David is delta-tagged and gamma-tagged.
Alice is charlie-tagged.
Bruno is foxtrot-tagged.
Clara is alpha-link... | Maybe | {"premise": ["Clara is alpha tagged.", "Elena is alpha tagged.", "Elena is bravo tagged.", "Clara is foxtrot tagged.", "Elena is foxtrot tagged.", "Elena is gamma tagged.", "Clara is alpha-linked to Elena.", "Elena is lambda tagged.", "David is delta tagged.", "David is gamma tagged.", "Alice is charlie tagged.", "Brun... | 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: ((\v0.((a ((v0 v0) (\v1.v1))) v0)) (\v0.((\v0.v0) ((\v1.b) (v0 v0)))))
The answer is the β-normal form (compared up to α-equivalence). | ((a (b (\x0.x0))) (\x1.b)) | {"term": "((\\v0.((a ((v0 v0) (\\v1.v1))) v0)) (\\v0.((\\v0.v0) ((\\v1.b) (v0 v0)))))", "normal_form": "((a (b (\\x0.x0))) (\\x1.b))", "beta_steps": 6, "has_shadowing": true, "shadowing": 1, "capture_risk": 0, "alpha_renaming": 0, "syntactic_alpha_renaming": 0, "skeleton": ["a", ["l", ["a", ["a", "v", ["a", ["a", "v", ... | 0 | instruct |
most_probable_evidence | Factor a is independently true with probability 0.3.
Factor b is independently true with probability 0.3.
Factor c is independently true with probability 0.6.
Factor d is independently true with probability 0.4.
Factor f is independently true with probability 0.4.
The observation holds exactly when (((factor d and fact... | 0 2 5 7 9 | {"problog": "0.3::a.\n0.3::b.\n0.6::c.\n0.4::d.\n0.4::f.\nobserved :- (((d,f);\\+(((\\+c;d),(\\+f;\\+b)))),((d;f),a)).\nevidence(observed,true).", "english": "Factor a is independently true with probability 0.3.\nFactor b is independently true with probability 0.3.\nFactor c is independently true with probability 0.6.\... | 5 | instruct |
finite_automaton_execution | States:
states 0..6, start state 2, accepting states {0, 2, 5}
Alphabet:
{a, b}
Transitions:
state 0: on a -> {3, 6}; on b -> {1, 5}
state 1: on a -> {1, 4}; on b -> {1, 5}
state 2: on a -> {3, 4}; on b -> {1}
state 3: on a -> {6}; on b -> {5}
state 4: on a -> {0}; on b -> {1, 4}
state 5: on a -> {2, 6}; on b -> {1}
... | 7 | {"payload": {"states": "states 0..6, start state 2, accepting states {0, 2, 5}", "alphabet": "{a, b}", "transitions": "state 0: on a -> {3, 6}; on b -> {1, 5}\nstate 1: on a -> {1, 4}; on b -> {1, 5}\nstate 2: on a -> {3, 4}; on b -> {1}\nstate 3: on a -> {6}; on b -> {5}\nstate 4: on a -> {0}; on b -> {1, 4}\nstate 5:... | 1 | instruct |
constrained_continuation | Complete <HOLE> according to the grammar.
GRAMMAR:
B -> 'where'
A -> 'writer' S
S -> A
A -> '<' A '>'
A -> B
SENTENCE:
< < writer < <HOLE> >
Return only the missing 3 tokens. | where > > | {"g": "B -> 'where'\nA -> 'writer' S\nS -> A\nA -> '<' A '>'\nA -> B", "start": "S", "k": 3, "prefix": ["<", "<", "writer", "<"], "suffix": [">"], "sentence": "< < writer < <HOLE> >", "n_candidates": 1, "n_reachable": 15, "finite_space_exhaustively_checked": true, "_time": 0.2905008792877197, "_task": "constrained_cont... | 1 | instruct |
code_runnability | Predict whether this Python call runs successfully or raises an exception.
```python
def fn5(p6, p7):
return fn2(p6, p7) - ((p6 if p6 >= -3 else p6) + (p7 if 3 != -5 else p6))
def fn2(p3, p4):
return p3
def endpoint(arg1):
seq8 = [fn2(arg1, arg1), arg1, arg1, fn5(4 - -2, fn2(arg1, arg1)) if -5 > arg1 or (... | ZeroDivisionError | {"code": "def fn5(p6, p7):\n return fn2(p6, p7) - ((p6 if p6 >= -3 else p6) + (p7 if 3 != -5 else p6))\n\ndef fn2(p3, p4):\n return p3\n\ndef endpoint(arg1):\n seq8 = [fn2(arg1, arg1), arg1, arg1, fn5(4 - -2, fn2(arg1, arg1)) if -5 > arg1 or (5 > arg1 or 2 == arg1) else arg1, arg1, (arg1 if 3 <= arg1 else arg1... | 4 | instruct |
dynamic_programming | States: A B C D E
Observations: 3 1 3 2 2 0 2 1 1 2 2 3
Start: A=4 B=-2 C=0 D=5 E=6
Transitions (rows=from, columns=A B C D E):
A: 2 -1 5 -6 2
B: 4 5 4 1 -4
C: 0 4 -6 6 -1
D: -2 5 6 1 2
E: 5 4 6 -3 -5
Emissions (rows=state, columns=0..3):
A: -3 6 0 -2
B: -2 -1 0 0
C: -1 0 -3 1
D: -3 -3 0 5
E: -3 -6 3 -2
Score a state s... | D C D B B B B A A E C D | {"labels": ["A", "B", "C", "D", "E"], "obs": [3, 1, 3, 2, 2, 0, 2, 1, 1, 2, 2, 3], "start": [4, -2, 0, 5, 6], "trans": [[2, -1, 5, -6, 2], [4, 5, 4, 1, -4], [0, 4, -6, 6, -1], [-2, 5, 6, 1, 2], [5, 4, 6, -3, -5]], "emit": [[-3, 6, 0, -2], [-2, -1, 0, 0], [-1, 0, -3, 1], [-3, -3, 0, 5], [-3, -6, 3, -2]], "_time": 0.0004... | 6 | instruct |
table_statistics | Table:
[{'J': -0.35, 'V': 0.84, 'S': -1.1, 'M': 0.18, 'C': -0.48}, {'J': 2.89, 'V': 3.66, 'S': 0.21, 'M': 2.79, 'C': 1.29}, {'J': 2.3, 'V': 0.81, 'S': 1.69, 'M': -0.55, 'C': -0.55}, {'J': -2.33, 'V': -1.38, 'S': -1.4, 'M': 1.0, 'C': -1.66}, {'J': -0.99, 'V': 0.61, 'S': -1.11, 'M': 0.82, 'C': -0.89}, {'J': 0.7, 'V': 1.0... | S | {"table": "[{'J': -0.35, 'V': 0.84, 'S': -1.1, 'M': 0.18, 'C': -0.48}, {'J': 2.89, 'V': 3.66, 'S': 0.21, 'M': 2.79, 'C': 1.29}, {'J': 2.3, 'V': 0.81, 'S': 1.69, 'M': -0.55, 'C': -0.55}, {'J': -2.33, 'V': -1.38, 'S': -1.4, 'M': 1.0, 'C': -1.66}, {'J': -0.99, 'V': 0.61, 'S': -1.11, 'M': 0.82, 'C': -0.89}, {'J': 0.7, 'V':... | 2 | 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'... | n4 | {"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,n3). edge(n0,n5). edge(n1,n2). edge(n1,n4). edge(n2,n5). edge(n2,n6). edge(n3,n5). edge(n3,n6).\nleaf(n4). leaf(n5). leaf(n6).\nvalue(n0,90). value(n1,50). value(n2,30). val... | 0 | instruct |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.