Dataset Viewer
Auto-converted to Parquet Duplicate
task_id
large_string
domain
large_string
difficulty
int64
config_id
large_string
strategy
large_string
model_checkpoint
large_string
model_revision
large_string
sampling_config
large_string
compute_budget
large_string
budget_definition
large_string
budget_units
large_string
allowed_tools
large_string
timestamp
large_string
harness_version
large_string
environment
large_string
prompt_template_version
large_string
run_id
large_string
row_kind
large_string
sample_index
float64
repeat_index
int64
seed
int64
final_answer
large_string
extraction_method
large_string
verified_result
bool
verifier_name
large_string
parse_error
bool
confidence
float64
confidence_source
large_string
token_usage
large_string
latency
large_string
raw_output
large_string
correct
int64
error
large_string
cost_usd
null
tool_calls_made
float64
prompt
large_string
answer
large_string
answer_type
large_string
source
large_string
source_license
large_string
contamination_risk
large_string
generator
large_string
repeat_id
large_string
arithmetic-1-0000
arithmetic
1
direct_cap48
direct
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"direct","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":false,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped.
tokens
[]
2026-11-16T17:52:02+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
62269b9f5cab7b0777202784
final
null
0
1,000
120
last_line
true
exact_int@1
false
0.765389
self_certainty_mean_logprob
{"completion_tokens":3,"prompt_tokens":75,"total_tokens":78}
{"completion_tokens_at_budget":3,"decode_s":3.1897,"latency_source":"measured","prefill_s":0.947,"tokens_per_second":0.941,"wall_clock_s":4.1367}
120
1
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Farid has 88 envelopes and buys 32 more. How many envelopes does Farid have now?
120
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
62269b9f5cab7b0777202784#r0
arithmetic-2-0003
arithmetic
2
direct_cap48
direct
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"direct","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":false,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped.
tokens
[]
2026-11-16T17:52:04+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
abb61b51059a241a818c1089
final
null
0
1,000
107
last_line
false
exact_int@1
false
0.610906
self_certainty_mean_logprob
{"completion_tokens":3,"prompt_tokens":91,"total_tokens":94}
{"completion_tokens_at_budget":3,"decode_s":0.2586,"latency_source":"measured","prefill_s":1.0473,"tokens_per_second":11.601,"wall_clock_s":1.3059}
107
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Kavya had 82 bottles, then used 9 of them. A friend later gave Kavya 25 more bottles. How many bottles does Kavya have now?
98
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
abb61b51059a241a818c1089#r0
arithmetic-3-0006
arithmetic
3
direct_cap48
direct
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"direct","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":false,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped.
tokens
[]
2026-11-16T17:52:06+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
283ce971ca1d9f93e5863af9
final
null
0
1,000
29
last_line
false
exact_int@1
false
0.347102
self_certainty_mean_logprob
{"completion_tokens":2,"prompt_tokens":84,"total_tokens":86}
{"completion_tokens_at_budget":2,"decode_s":0.1543,"latency_source":"measured","prefill_s":0.9893,"tokens_per_second":12.963,"wall_clock_s":1.1436}
29
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Each box contains 7 candles. Ivo buys 15 boxes and then donates 16 candles. How many candles does Ivo have left?
89
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
283ce971ca1d9f93e5863af9#r0
code_reasoning-1-0000
code_reasoning
1
direct_cap48
direct
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"direct","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":false,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped.
tokens
[]
2026-11-16T17:52:08+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
ef60752311e7a165ed699291
final
null
0
1,000
18
last_line
false
exact_int@1
false
0.568631
self_certainty_mean_logprob
{"completion_tokens":2,"prompt_tokens":87,"total_tokens":89}
{"completion_tokens_at_budget":2,"decode_s":0.2476,"latency_source":"measured","prefill_s":0.9975,"tokens_per_second":8.078,"wall_clock_s":1.2451}
18
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python xs = [9, 7, 9, 6, 2] print(xs[2] * 3) ```
27
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
ef60752311e7a165ed699291#r0
code_reasoning-2-0003
code_reasoning
2
direct_cap48
direct
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"direct","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":false,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped.
tokens
[]
2026-11-16T17:52:11+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
b183350be73eb0154d8bc9b3
final
null
0
1,000
10
last_line
false
exact_int@1
false
0.259907
self_certainty_mean_logprob
{"completion_tokens":2,"prompt_tokens":87,"total_tokens":89}
{"completion_tokens_at_budget":2,"decode_s":0.116,"latency_source":"measured","prefill_s":1.0273,"tokens_per_second":17.246,"wall_clock_s":1.1432}
10
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python s = 'hcjfabeeiffe' sub = s[3:8] print(len(set(sub)) + len(sub)) ```
9
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
b183350be73eb0154d8bc9b3#r0
code_reasoning-3-0006
code_reasoning
3
direct_cap48
direct
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"direct","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":false,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped.
tokens
[]
2026-11-16T17:52:14+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
4edfb00c7bc55f7975c36735
final
null
0
1,000
50
ANSWER\s*[:=]\s*([^\n]+)
false
exact_int@1
false
0.574966
self_certainty_mean_logprob
{"completion_tokens":6,"prompt_tokens":130,"total_tokens":136}
{"completion_tokens_at_budget":6,"decode_s":0.99,"latency_source":"measured","prefill_s":1.1621,"tokens_per_second":6.06,"wall_clock_s":2.1521}
ANSWER: 50
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python xs = [1, 1, 3, 3, 2, 2, 0, 3] counts = {} for v in xs: counts[v] = counts.get(v, 0) + 1 print(counts.get(4, 0) * 10 + len(counts)) ```
4
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
4edfb00c7bc55f7975c36735#r0
logic-1-0000
logic
1
direct_cap48
direct
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"direct","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":false,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped.
tokens
[]
2026-11-16T17:52:19+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
ba12744cc6e24e2dbae31e18
final
null
0
1,000
null
ANSWER\s*[:=]\s*([^\n]+)
false
exact_assignment@1
true
0.748957
self_certainty_mean_logprob
{"completion_tokens":14,"prompt_tokens":104,"total_tokens":118}
{"completion_tokens_at_budget":14,"decode_s":2.6302,"latency_source":"measured","prefill_s":1.008,"tokens_per_second":5.323,"wall_clock_s":3.6382}
ANSWER: NAME=position, NAME=position, NAME=position
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe. Positions: 1, 2, 3 (each used exactly once). Constraints: - Chloe and Ana are not in adjacent positions. - Ben is immediately before Chloe.
{"Ana": 1, "Ben": 2, "Chloe": 3}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
ba12744cc6e24e2dbae31e18#r0
logic-2-0003
logic
2
direct_cap48
direct
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"direct","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":false,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped.
tokens
[]
2026-11-16T17:52:24+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
e35c0eb8aef1f6677603a2a5
final
null
0
1,000
null
raw_tail
false
exact_assignment@1
true
0.871829
self_certainty_mean_logprob
{"completion_tokens":15,"prompt_tokens":135,"total_tokens":150}
{"completion_tokens_at_budget":15,"decode_s":2.8205,"latency_source":"measured","prefill_s":1.1842,"tokens_per_second":5.318,"wall_clock_s":4.0047}
NAME=position, NAME=position, NAME=position, NAME=position
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe, Diego. Positions: 1, 2, 3, 4 (each used exactly once). Constraints: - Diego and Ana are not in adjacent positions. - Chloe is immediately before Die...
{"Ana": 2, "Ben": 1, "Chloe": 3, "Diego": 4}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
e35c0eb8aef1f6677603a2a5#r0
logic-3-0006
logic
3
direct_cap48
direct
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"direct","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":false,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped.
tokens
[]
2026-11-16T17:52:31+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
745c410144465f0eaa4f80cf
final
null
0
1,000
null
raw_tail
false
exact_assignment@1
true
0.850021
self_certainty_mean_logprob
{"completion_tokens":19,"prompt_tokens":159,"total_tokens":178}
{"completion_tokens_at_budget":19,"decode_s":3.8997,"latency_source":"measured","prefill_s":1.5369,"tokens_per_second":4.872,"wall_clock_s":5.4366}
NAME=position, NAME=position, NAME=position, NAME=position, NAME=position
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe, Diego. Positions: 1, 2, 3, 4 (each used exactly once). Constraints: - Ben and Chloe are not in adjacent positions. - Diego is not in position 1. - B...
{"Ana": 1, "Ben": 4, "Chloe": 2, "Diego": 3}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
745c410144465f0eaa4f80cf#r0
arithmetic-1-0000
arithmetic
1
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:53:00+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
e5950376fcb7bd2e2e97e04e
final
null
0
2,000
32
last_line
false
exact_int@1
false
0.744398
self_certainty_mean_logprob
{"completion_tokens":48,"prompt_tokens":77,"total_tokens":125}
{"completion_tokens_at_budget":48,"decode_s":9.8187,"latency_source":"estimated_linear","prefill_s":0.9892,"tokens_per_second":4.889,"wall_clock_s":10.8079}
To solve this problem, we need to add the number of envelopes Farid initially had to the number he bought: 1. Initial number of envelopes = 88 2. Number of envelopes bought = 32 So, the
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Farid has 88 envelopes and buys 32 more. How many envelopes does Farid have now?
120
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
e5950376fcb7bd2e2e97e04e#r0
arithmetic-1-0000
arithmetic
1
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":96,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=96: the model may emit at most 96 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:53:00+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
ca7d8a5f5c06ce2e0418b8a6
final
null
0
2,000
3
last_line
false
exact_int@1
false
0.801773
self_certainty_mean_logprob
{"completion_tokens":96,"prompt_tokens":77,"total_tokens":173}
{"completion_tokens_at_budget":96,"decode_s":19.6374,"latency_source":"estimated_linear","prefill_s":0.9892,"tokens_per_second":4.889,"wall_clock_s":20.6266}
To solve this problem, we need to add the number of envelopes Farid initially had to the number he bought: 1. Initial number of envelopes = 88 2. Number of envelopes bought = 32 So, the total number of envelopes Farid has now is: \[ \text{Total envelopes} = \text{Initial envelopes} + \text{Bought envelopes} \] \[ \t...
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Farid has 88 envelopes and buys 32 more. How many envelopes does Farid have now?
120
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
ca7d8a5f5c06ce2e0418b8a6#r0
arithmetic-1-0000
arithmetic
1
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":160,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=160: the model may emit at most 160 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:53:00+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
a8a5bdc033c0d30108718480
final
null
0
2,000
120
ANSWER\s*[:=]\s*([^\n]+)
true
exact_int@1
false
0.816839
self_certainty_mean_logprob
{"completion_tokens":130,"prompt_tokens":77,"total_tokens":207}
{"completion_tokens_at_budget":130,"decode_s":26.5923,"latency_source":"measured","prefill_s":0.9892,"tokens_per_second":4.889,"wall_clock_s":27.5815}
To solve this problem, we need to add the number of envelopes Farid initially had to the number he bought: 1. Initial number of envelopes = 88 2. Number of envelopes bought = 32 So, the total number of envelopes Farid has now is: \[ \text{Total envelopes} = \text{Initial envelopes} + \text{Bought envelopes} \] \[ \t...
1
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Farid has 88 envelopes and buys 32 more. How many envelopes does Farid have now?
120
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
a8a5bdc033c0d30108718480#r0
arithmetic-2-0003
arithmetic
2
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:53:27+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
c44fbba6a6459c164d8e6f40
final
null
0
2,000
7
last_line
false
exact_int@1
false
0.837081
self_certainty_mean_logprob
{"completion_tokens":48,"prompt_tokens":93,"total_tokens":141}
{"completion_tokens_at_budget":48,"decode_s":9.8002,"latency_source":"estimated_linear","prefill_s":1.0944,"tokens_per_second":4.898,"wall_clock_s":10.8946}
To solve this problem, let's break it down step by step: 1. Initially, Kavya has 82 bottles. 2. She uses 9 bottles, so she now has \(82 - 9 = 7
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Kavya had 82 bottles, then used 9 of them. A friend later gave Kavya 25 more bottles. How many bottles does Kavya have now?
98
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
c44fbba6a6459c164d8e6f40#r0
arithmetic-2-0003
arithmetic
2
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":96,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=96: the model may emit at most 96 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:53:27+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
c286e85633c6c742f8982539
final
null
0
2,000
9
last_line
false
exact_int@1
false
0.807405
self_certainty_mean_logprob
{"completion_tokens":96,"prompt_tokens":93,"total_tokens":189}
{"completion_tokens_at_budget":96,"decode_s":19.6005,"latency_source":"estimated_linear","prefill_s":1.0944,"tokens_per_second":4.898,"wall_clock_s":20.6949}
To solve this problem, let's break it down step by step: 1. Initially, Kavya has 82 bottles. 2. She uses 9 bottles, so she now has \(82 - 9 = 73\) bottles left. 3. Then, her friend gives her 25 more bottles. So, we add the 25 bottles to the 73 bottles she already has: \[73 + 25 = 9
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Kavya had 82 bottles, then used 9 of them. A friend later gave Kavya 25 more bottles. How many bottles does Kavya have now?
98
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
c286e85633c6c742f8982539#r0
arithmetic-2-0003
arithmetic
2
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":160,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=160: the model may emit at most 160 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:53:27+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
cb9b9010240c857e27863732
final
null
0
2,000
98
\\boxed\{([^}]*)\}
true
exact_int@1
false
0.816261
self_certainty_mean_logprob
{"completion_tokens":122,"prompt_tokens":93,"total_tokens":215}
{"completion_tokens_at_budget":122,"decode_s":24.909,"latency_source":"measured","prefill_s":1.0944,"tokens_per_second":4.898,"wall_clock_s":26.0034}
To solve this problem, let's break it down step by step: 1. Initially, Kavya has 82 bottles. 2. She uses 9 bottles, so she now has \(82 - 9 = 73\) bottles left. 3. Then, her friend gives her 25 more bottles. So, we add the 25 bottles to the 73 bottles she already has: \[73 + 25 = 98\] Therefore, Kavya now has 98 bot...
1
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Kavya had 82 bottles, then used 9 of them. A friend later gave Kavya 25 more bottles. How many bottles does Kavya have now?
98
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
cb9b9010240c857e27863732#r0
arithmetic-3-0006
arithmetic
3
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:54:06+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
0446e8ca8b6c97218ddd82e3
final
null
0
2,000
1
last_line
false
exact_int@1
false
0.826003
self_certainty_mean_logprob
{"completion_tokens":48,"prompt_tokens":86,"total_tokens":134}
{"completion_tokens_at_budget":48,"decode_s":10.914,"latency_source":"estimated_linear","prefill_s":1.0855,"tokens_per_second":4.398,"wall_clock_s":11.9995}
To solve this problem, we need to follow these steps: 1. Calculate the total number of candles in the 15 boxes. 2. Subtract the number of candles donated from the total. Let's start with step 1: Each
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Each box contains 7 candles. Ivo buys 15 boxes and then donates 16 candles. How many candles does Ivo have left?
89
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
0446e8ca8b6c97218ddd82e3#r0
arithmetic-3-0006
arithmetic
3
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":96,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=96: the model may emit at most 96 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:54:06+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
c58bab124097de27d3115bf1
final
null
0
2,000
105
last_line
false
exact_int@1
false
0.875498
self_certainty_mean_logprob
{"completion_tokens":96,"prompt_tokens":86,"total_tokens":182}
{"completion_tokens_at_budget":96,"decode_s":21.828,"latency_source":"estimated_linear","prefill_s":1.0855,"tokens_per_second":4.398,"wall_clock_s":22.9135}
To solve this problem, we need to follow these steps: 1. Calculate the total number of candles in the 15 boxes. 2. Subtract the number of candles donated from the total. Let's start with step 1: Each box contains 7 candles, so for 15 boxes: \[ 15 \text{ boxes} \times 7 \text{ candles/box} = 105 \text{ candles} \] N...
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Each box contains 7 candles. Ivo buys 15 boxes and then donates 16 candles. How many candles does Ivo have left?
89
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
c58bab124097de27d3115bf1#r0
arithmetic-3-0006
arithmetic
3
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":160,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=160: the model may emit at most 160 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:54:06+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
ca86dc5d38ef821959e7b2f1
final
null
0
2,000
null
[Ff]inal answer\s*(?:is|
false
exact_int@1
true
0.893215
self_certainty_mean_logprob
{"completion_tokens":160,"prompt_tokens":86,"total_tokens":246}
{"completion_tokens_at_budget":160,"decode_s":36.38,"latency_source":"measured","prefill_s":1.0855,"tokens_per_second":4.398,"wall_clock_s":37.4655}
To solve this problem, we need to follow these steps: 1. Calculate the total number of candles in the 15 boxes. 2. Subtract the number of candles donated from the total. Let's start with step 1: Each box contains 7 candles, so for 15 boxes: \[ 15 \text{ boxes} \times 7 \text{ candles/box} = 105 \text{ candles} \] N...
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Each box contains 7 candles. Ivo buys 15 boxes and then donates 16 candles. How many candles does Ivo have left?
89
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
ca86dc5d38ef821959e7b2f1#r0
code_reasoning-1-0000
code_reasoning
1
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:54:42+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
c5208b1ea90ece60dceed42f
final
null
0
2,000
6
last_line
false
exact_int@1
false
0.737609
self_certainty_mean_logprob
{"completion_tokens":48,"prompt_tokens":91,"total_tokens":139}
{"completion_tokens_at_budget":48,"decode_s":10.3535,"latency_source":"estimated_linear","prefill_s":1.9152,"tokens_per_second":4.636,"wall_clock_s":12.2686}
To trace the given Python code and determine the single integer it prints, let's break down the steps: 1. **Initialization**: The list `xs` is defined with elements `[9, 7, 9, 6,
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python xs = [9, 7, 9, 6, 2] print(xs[2] * 3) ```
27
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
c5208b1ea90ece60dceed42f#r0
code_reasoning-1-0000
code_reasoning
1
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":96,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=96: the model may emit at most 96 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:54:42+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
eb8e3ff41ddeb8c15c91ae2b
final
null
0
2,000
3
last_line
false
exact_int@1
false
0.733066
self_certainty_mean_logprob
{"completion_tokens":96,"prompt_tokens":91,"total_tokens":187}
{"completion_tokens_at_budget":96,"decode_s":20.707,"latency_source":"estimated_linear","prefill_s":1.9152,"tokens_per_second":4.636,"wall_clock_s":22.6221}
To trace the given Python code and determine the single integer it prints, let's break down the steps: 1. **Initialization**: The list `xs` is defined with elements `[9, 7, 9, 6, 2]`. 2. **Accessing Elements**: We access the element at index `2` in the list using `xs[2]`. This gives us the value `9`. 3. **Multiplicati...
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python xs = [9, 7, 9, 6, 2] print(xs[2] * 3) ```
27
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
eb8e3ff41ddeb8c15c91ae2b#r0
code_reasoning-1-0000
code_reasoning
1
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":160,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=160: the model may emit at most 160 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:54:42+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
db77dcc38afb187cc8a3e26e
final
null
0
2,000
27
ANSWER\s*[:=]\s*([^\n]+)
true
exact_int@1
false
0.703545
self_certainty_mean_logprob
{"completion_tokens":149,"prompt_tokens":91,"total_tokens":240}
{"completion_tokens_at_budget":149,"decode_s":32.1389,"latency_source":"measured","prefill_s":1.9152,"tokens_per_second":4.636,"wall_clock_s":34.0541}
To trace the given Python code and determine the single integer it prints, let's break down the steps: 1. **Initialization**: The list `xs` is defined with elements `[9, 7, 9, 6, 2]`. 2. **Accessing Elements**: We access the element at index `2` in the list using `xs[2]`. This gives us the value `9`. 3. **Multiplicati...
1
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python xs = [9, 7, 9, 6, 2] print(xs[2] * 3) ```
27
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
db77dcc38afb187cc8a3e26e#r0
code_reasoning-2-0003
code_reasoning
2
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:55:18+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
385154a7889d53a48ae2eb34
final
null
0
2,000
2
last_line
false
exact_int@1
false
0.731435
self_certainty_mean_logprob
{"completion_tokens":48,"prompt_tokens":91,"total_tokens":139}
{"completion_tokens_at_budget":48,"decode_s":10.095,"latency_source":"estimated_linear","prefill_s":1.0588,"tokens_per_second":4.755,"wall_clock_s":11.1537}
To trace the given Python code and determine the single integer it prints, let's break down the steps: 1. **Initialization**: The variable `s` is initialized with the string `'hcjfabeeiffe'`. 2. **Substring
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python s = 'hcjfabeeiffe' sub = s[3:8] print(len(set(sub)) + len(sub)) ```
9
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
385154a7889d53a48ae2eb34#r0
code_reasoning-2-0003
code_reasoning
2
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":96,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=96: the model may emit at most 96 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:55:18+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
035d567495a8007d961257cb
final
null
0
2,000
3
last_line
false
exact_int@1
false
0.707663
self_certainty_mean_logprob
{"completion_tokens":96,"prompt_tokens":91,"total_tokens":187}
{"completion_tokens_at_budget":96,"decode_s":20.1899,"latency_source":"estimated_linear","prefill_s":1.0588,"tokens_per_second":4.755,"wall_clock_s":21.2487}
To trace the given Python code and determine the single integer it prints, let's break down the steps: 1. **Initialization**: The variable `s` is initialized with the string `'hcjfabeeiffe'`. 2. **Substring Extraction**: The substring from index 3 to index 7 (inclusive) is extracted using slicing (`s[3:8]`). This giv...
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python s = 'hcjfabeeiffe' sub = s[3:8] print(len(set(sub)) + len(sub)) ```
9
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
035d567495a8007d961257cb#r0
code_reasoning-2-0003
code_reasoning
2
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":160,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=160: the model may emit at most 160 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:55:18+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
08877a8576115775f9bbdcaa
final
null
0
2,000
6
last_line
false
exact_int@1
false
0.67577
self_certainty_mean_logprob
{"completion_tokens":160,"prompt_tokens":91,"total_tokens":251}
{"completion_tokens_at_budget":160,"decode_s":33.6498,"latency_source":"measured","prefill_s":1.0588,"tokens_per_second":4.755,"wall_clock_s":34.7086}
To trace the given Python code and determine the single integer it prints, let's break down the steps: 1. **Initialization**: The variable `s` is initialized with the string `'hcjfabeeiffe'`. 2. **Substring Extraction**: The substring from index 3 to index 7 (inclusive) is extracted using slicing (`s[3:8]`). This giv...
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python s = 'hcjfabeeiffe' sub = s[3:8] print(len(set(sub)) + len(sub)) ```
9
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
08877a8576115775f9bbdcaa#r0
code_reasoning-3-0006
code_reasoning
3
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:55:53+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
793f1329d634d35ace5edf5d
final
null
0
2,000
2
last_line
false
exact_int@1
false
0.625407
self_certainty_mean_logprob
{"completion_tokens":48,"prompt_tokens":134,"total_tokens":182}
{"completion_tokens_at_budget":48,"decode_s":9.7911,"latency_source":"estimated_linear","prefill_s":1.112,"tokens_per_second":4.902,"wall_clock_s":10.9031}
To trace the given Python code, let's break down each part of the logic: 1. **Initialization**: The list `xs` is defined with some elements. 2. **Counting Elements**: A dictionary `counts` is initialized to
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python xs = [1, 1, 3, 3, 2, 2, 0, 3] counts = {} for v in xs: counts[v] = counts.get(v, 0) + 1 print(counts.get(4, 0) * 10 + len(counts)) ```
4
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
793f1329d634d35ace5edf5d#r0
code_reasoning-3-0006
code_reasoning
3
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":96,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=96: the model may emit at most 96 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:55:53+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
64277419bb3a95e2ae08e8d3
final
null
0
2,000
4
last_line
true
exact_int@1
false
0.668023
self_certainty_mean_logprob
{"completion_tokens":96,"prompt_tokens":134,"total_tokens":230}
{"completion_tokens_at_budget":96,"decode_s":19.5822,"latency_source":"estimated_linear","prefill_s":1.112,"tokens_per_second":4.902,"wall_clock_s":20.6942}
To trace the given Python code, let's break down each part of the logic: 1. **Initialization**: The list `xs` is defined with some elements. 2. **Counting Elements**: A dictionary `counts` is initialized to keep track of how many times each element appears in the list. 3. **Iteration**: For each element `v` in the lis...
1
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python xs = [1, 1, 3, 3, 2, 2, 0, 3] counts = {} for v in xs: counts[v] = counts.get(v, 0) + 1 print(counts.get(4, 0) * 10 + len(counts)) ```
4
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
64277419bb3a95e2ae08e8d3#r0
code_reasoning-3-0006
code_reasoning
3
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":160,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=160: the model may emit at most 160 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:55:53+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
5946721712bfac0a3316e204
final
null
0
2,000
2
last_line
false
exact_int@1
false
0.711625
self_certainty_mean_logprob
{"completion_tokens":160,"prompt_tokens":134,"total_tokens":294}
{"completion_tokens_at_budget":160,"decode_s":32.637,"latency_source":"measured","prefill_s":1.112,"tokens_per_second":4.902,"wall_clock_s":33.749}
To trace the given Python code, let's break down each part of the logic: 1. **Initialization**: The list `xs` is defined with some elements. 2. **Counting Elements**: A dictionary `counts` is initialized to keep track of how many times each element appears in the list. 3. **Iteration**: For each element `v` in the lis...
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python xs = [1, 1, 3, 3, 2, 2, 0, 3] counts = {} for v in xs: counts[v] = counts.get(v, 0) + 1 print(counts.get(4, 0) * 10 + len(counts)) ```
4
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
5946721712bfac0a3316e204#r0
logic-1-0000
logic
1
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:56:28+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
9b5774591c719ba2ea245a46
final
null
0
2,000
null
last_line
false
exact_assignment@1
true
0.736265
self_certainty_mean_logprob
{"completion_tokens":48,"prompt_tokens":105,"total_tokens":153}
{"completion_tokens_at_budget":48,"decode_s":9.8611,"latency_source":"estimated_linear","prefill_s":1.022,"tokens_per_second":4.868,"wall_clock_s":10.8831}
To assign each person to exactly one distinct position while adhering to the given constraints, we can follow these steps: 1. **Chloe and Ana cannot be in adjacent positions**. 2. **Ben must be immediately before Chloe**.
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe. Positions: 1, 2, 3 (each used exactly once). Constraints: - Chloe and Ana are not in adjacent positions. - Ben is immediately before Chloe.
{"Ana": 1, "Ben": 2, "Chloe": 3}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
9b5774591c719ba2ea245a46#r0
logic-1-0000
logic
1
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":96,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=96: the model may emit at most 96 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:56:28+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
6e4f20913c31e813ce7726c8
final
null
0
2,000
null
last_line
false
exact_assignment@1
true
0.572523
self_certainty_mean_logprob
{"completion_tokens":96,"prompt_tokens":105,"total_tokens":201}
{"completion_tokens_at_budget":96,"decode_s":19.7222,"latency_source":"estimated_linear","prefill_s":1.022,"tokens_per_second":4.868,"wall_clock_s":20.7442}
To assign each person to exactly one distinct position while adhering to the given constraints, we can follow these steps: 1. **Chloe and Ana cannot be in adjacent positions**. 2. **Ben must be immediately before Chloe**. Let's start by placing Ben immediately before Chloe. This ensures that Ben is not adjacent to Ch...
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe. Positions: 1, 2, 3 (each used exactly once). Constraints: - Chloe and Ana are not in adjacent positions. - Ben is immediately before Chloe.
{"Ana": 1, "Ben": 2, "Chloe": 3}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
6e4f20913c31e813ce7726c8#r0
logic-1-0000
logic
1
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":160,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=160: the model may emit at most 160 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:56:28+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
83bcbea375aec35ee209b214
final
null
0
2,000
null
last_line
false
exact_assignment@1
true
0.521605
self_certainty_mean_logprob
{"completion_tokens":160,"prompt_tokens":105,"total_tokens":265}
{"completion_tokens_at_budget":160,"decode_s":32.8703,"latency_source":"measured","prefill_s":1.022,"tokens_per_second":4.868,"wall_clock_s":33.8923}
To assign each person to exactly one distinct position while adhering to the given constraints, we can follow these steps: 1. **Chloe and Ana cannot be in adjacent positions**. 2. **Ben must be immediately before Chloe**. Let's start by placing Ben immediately before Chloe. This ensures that Ben is not adjacent to Ch...
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe. Positions: 1, 2, 3 (each used exactly once). Constraints: - Chloe and Ana are not in adjacent positions. - Ben is immediately before Chloe.
{"Ana": 1, "Ben": 2, "Chloe": 3}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
83bcbea375aec35ee209b214#r0
logic-2-0003
logic
2
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:57:03+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
51a339c354e086fb3980f62d
final
null
0
2,000
null
last_line
false
exact_assignment@1
true
0.750638
self_certainty_mean_logprob
{"completion_tokens":48,"prompt_tokens":136,"total_tokens":184}
{"completion_tokens_at_budget":48,"decode_s":9.8046,"latency_source":"estimated_linear","prefill_s":1.1565,"tokens_per_second":4.896,"wall_clock_s":10.9611}
To assign each person to exactly one distinct position while adhering to the given constraints, we can follow these steps: 1. **Diego and Ana cannot be in adjacent positions**. 2. **Chloe is immediately before Diego**.
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe, Diego. Positions: 1, 2, 3, 4 (each used exactly once). Constraints: - Diego and Ana are not in adjacent positions. - Chloe is immediately before Die...
{"Ana": 2, "Ben": 1, "Chloe": 3, "Diego": 4}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
51a339c354e086fb3980f62d#r0
logic-2-0003
logic
2
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":96,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=96: the model may emit at most 96 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:57:03+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
a9b9814e5bc744e2ad117c96
final
null
0
2,000
null
last_line
false
exact_assignment@1
true
0.730476
self_certainty_mean_logprob
{"completion_tokens":96,"prompt_tokens":136,"total_tokens":232}
{"completion_tokens_at_budget":96,"decode_s":19.6092,"latency_source":"estimated_linear","prefill_s":1.1565,"tokens_per_second":4.896,"wall_clock_s":20.7657}
To assign each person to exactly one distinct position while adhering to the given constraints, we can follow these steps: 1. **Diego and Ana cannot be in adjacent positions**. 2. **Chloe is immediately before Diego**. 3. **Ben is not in position 4**. 4. **Ben and Chloe are not in adjacent positions**. Let's start wi...
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe, Diego. Positions: 1, 2, 3, 4 (each used exactly once). Constraints: - Diego and Ana are not in adjacent positions. - Chloe is immediately before Die...
{"Ana": 2, "Ben": 1, "Chloe": 3, "Diego": 4}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
a9b9814e5bc744e2ad117c96#r0
logic-2-0003
logic
2
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":160,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=160: the model may emit at most 160 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:57:03+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
6220d68214f5b5176610597d
final
null
0
2,000
null
last_line
false
exact_assignment@1
true
0.725792
self_certainty_mean_logprob
{"completion_tokens":160,"prompt_tokens":136,"total_tokens":296}
{"completion_tokens_at_budget":160,"decode_s":32.682,"latency_source":"measured","prefill_s":1.1565,"tokens_per_second":4.896,"wall_clock_s":33.8385}
To assign each person to exactly one distinct position while adhering to the given constraints, we can follow these steps: 1. **Diego and Ana cannot be in adjacent positions**. 2. **Chloe is immediately before Diego**. 3. **Ben is not in position 4**. 4. **Ben and Chloe are not in adjacent positions**. Let's start wi...
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe, Diego. Positions: 1, 2, 3, 4 (each used exactly once). Constraints: - Diego and Ana are not in adjacent positions. - Chloe is immediately before Die...
{"Ana": 2, "Ben": 1, "Chloe": 3, "Diego": 4}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
6220d68214f5b5176610597d#r0
logic-3-0006
logic
3
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":48,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=48: the model may emit at most 48 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:57:39+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
d8d26fefaf572f287814ca25
final
null
0
2,000
null
last_line
false
exact_assignment@1
true
0.765321
self_certainty_mean_logprob
{"completion_tokens":48,"prompt_tokens":160,"total_tokens":208}
{"completion_tokens_at_budget":48,"decode_s":9.8329,"latency_source":"estimated_linear","prefill_s":1.212,"tokens_per_second":4.882,"wall_clock_s":11.0449}
To assign each person to exactly one distinct position while adhering to the given constraints, we can follow these steps: 1. **Ben cannot be in position 1**. 2. **Ana cannot be in position 4**. 3
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe, Diego. Positions: 1, 2, 3, 4 (each used exactly once). Constraints: - Ben and Chloe are not in adjacent positions. - Diego is not in position 1. - B...
{"Ana": 1, "Ben": 4, "Chloe": 2, "Diego": 3}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
d8d26fefaf572f287814ca25#r0
logic-3-0006
logic
3
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":96,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=96: the model may emit at most 96 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:57:39+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
d5a7f7bdea861e4acaa20a7d
final
null
0
2,000
null
last_line
false
exact_assignment@1
true
0.74484
self_certainty_mean_logprob
{"completion_tokens":96,"prompt_tokens":160,"total_tokens":256}
{"completion_tokens_at_budget":96,"decode_s":19.6658,"latency_source":"estimated_linear","prefill_s":1.212,"tokens_per_second":4.882,"wall_clock_s":20.8778}
To assign each person to exactly one distinct position while adhering to the given constraints, we can follow these steps: 1. **Ben cannot be in position 1**. 2. **Ana cannot be in position 4**. 3. **Diego is not in position 1**. 4. **Ben is not in position 2**. 5. **Ana and Ben must not be in adjacent positions**. L...
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe, Diego. Positions: 1, 2, 3, 4 (each used exactly once). Constraints: - Ben and Chloe are not in adjacent positions. - Diego is not in position 1. - B...
{"Ana": 1, "Ben": 4, "Chloe": 2, "Diego": 3}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
d5a7f7bdea861e4acaa20a7d#r0
logic-3-0006
logic
3
cot_ladder
cot
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.0,"top_k":null,"top_p":1.0}
{"max_new_tokens":160,"max_tool_calls":0,"n_samples":1,"prefix_nested":true,"wall_clock_s":null}
max_new_tokens=160: the model may emit at most 160 new tokens per sample; no other budget axis is varied. Prompt length is not capped. prefix_nested=true: budget levels at this configuration are prefixes of a single greedy rollout, so the cap curve is exactly nested (identical decoded prefix).
tokens
[]
2026-11-16T17:57:39+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
f80bcc89fe143a32b177be93
final
null
0
2,000
{"This": 4}
last_line
false
exact_assignment@1
false
0.768294
self_certainty_mean_logprob
{"completion_tokens":160,"prompt_tokens":160,"total_tokens":320}
{"completion_tokens_at_budget":160,"decode_s":32.7764,"latency_source":"measured","prefill_s":1.212,"tokens_per_second":4.882,"wall_clock_s":33.9884}
To assign each person to exactly one distinct position while adhering to the given constraints, we can follow these steps: 1. **Ben cannot be in position 1**. 2. **Ana cannot be in position 4**. 3. **Diego is not in position 1**. 4. **Ben is not in position 2**. 5. **Ana and Ben must not be in adjacent positions**. L...
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe, Diego. Positions: 1, 2, 3, 4 (each used exactly once). Constraints: - Ben and Chloe are not in adjacent positions. - Diego is not in position 1. - B...
{"Ana": 1, "Ben": 4, "Chloe": 2, "Diego": 3}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
f80bcc89fe143a32b177be93#r0
arithmetic-1-0000
arithmetic
1
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:57:58+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
12b5fa82d1cfb1b361f069a3
sample
0
0
3,000
120
ANSWER\s*[:=]\s*([^\n]+)
true
exact_int@1
false
0.625763
self_certainty_mean_logprob
{"completion_tokens":16,"prompt_tokens":77,"total_tokens":93}
{"decode_s":5.6986,"latency_source":"measured","prefill_s":0.894,"tokens_per_second":2.808,"wall_clock_s":6.5925}
ANSWER: 120 Final answer: 120.
1
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Farid has 88 envelopes and buys 32 more. How many envelopes does Farid have now?
120
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
12b5fa82d1cfb1b361f069a3#r0
arithmetic-1-0000
arithmetic
1
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:57:58+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
cc22a99503206fdaa1f84ff7
sample
1
0
3,000
120
[Ff]inal answer\s*(?:is|
true
exact_int@1
false
0.539073
self_certainty_mean_logprob
{"completion_tokens":9,"prompt_tokens":77,"total_tokens":86}
{"decode_s":5.6986,"latency_source":"measured","prefill_s":0.894,"tokens_per_second":1.579,"wall_clock_s":6.5925}
The final answer is 120.
1
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Farid has 88 envelopes and buys 32 more. How many envelopes does Farid have now?
120
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
cc22a99503206fdaa1f84ff7#r0
arithmetic-1-0000
arithmetic
1
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:57:58+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
b2e3336795c8e4bb5a4e157a
sample
2
0
3,000
32
last_line
false
exact_int@1
false
0.770466
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":77,"total_tokens":141}
{"decode_s":5.6986,"latency_source":"measured","prefill_s":0.894,"tokens_per_second":11.231,"wall_clock_s":6.5925}
To solve this problem, let's break it down step-by-step: 1. **Initial Number of Envelopes**: Farid starts with 88 envelopes. 2. **New Purchase**: Farid buys 32 more envelopes. To find out how many envelopes Farid has now, we need to add these
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Farid has 88 envelopes and buys 32 more. How many envelopes does Farid have now?
120
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
b2e3336795c8e4bb5a4e157a#r0
arithmetic-1-0000
arithmetic
1
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:57:58+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
a96ecf8d0877f8d471bd9fb9
aggregate
null
0
3,000
120
majority_vote
true
exact@majority
false
0.666667
vote_agreement
{"completion_tokens":16,"per_sample_completion_tokens":[16,9,64],"prompt_tokens":77,"total_completion_tokens_all_samples":89,"total_tokens":93,"total_tokens_all_samples":320}
{"decode_s":5.6986,"latency_source":"measured","prefill_s":0.894,"tokens_per_second":2.808,"wall_clock_s":6.5925}
ANSWER: 120 Final answer: 120.
1
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Farid has 88 envelopes and buys 32 more. How many envelopes does Farid have now?
120
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
a96ecf8d0877f8d471bd9fb9#r0
arithmetic-2-0003
arithmetic
2
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:58:17+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
3c80f0ba21bcf5bb75f5c048
sample
0
0
3,000
25
last_line
false
exact_int@1
false
0.71535
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":93,"total_tokens":157}
{"decode_s":5.8839,"latency_source":"measured","prefill_s":0.9667,"tokens_per_second":10.877,"wall_clock_s":6.8505}
First, let's break down the problem step-by-step: 1. Initially, Kavya had 82 bottles. 2. She used 9 bottles. 3. Then, she received 25 more bottles from a friend. Now, let's calculate how many bottles Kavya has after these transactions:
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Kavya had 82 bottles, then used 9 of them. A friend later gave Kavya 25 more bottles. How many bottles does Kavya have now?
98
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
3c80f0ba21bcf5bb75f5c048#r0
arithmetic-2-0003
arithmetic
2
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:58:17+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
6b3c82450d0a44c33a799430
sample
1
0
3,000
25
last_line
false
exact_int@1
false
0.75885
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":93,"total_tokens":157}
{"decode_s":5.8839,"latency_source":"measured","prefill_s":0.9667,"tokens_per_second":10.877,"wall_clock_s":6.8505}
Let's break this down step-by-step: 1. Kavya initially had 82 bottles. 2. She used 9 of them, so she would have \( 82 - 9 = 73 \) bottles left. 3. Then, her friend gave her 25 more bottles,
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Kavya had 82 bottles, then used 9 of them. A friend later gave Kavya 25 more bottles. How many bottles does Kavya have now?
98
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
6b3c82450d0a44c33a799430#r0
arithmetic-2-0003
arithmetic
2
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:58:17+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
29f480f93fabcdaf9e346c88
sample
2
0
3,000
82
last_line
false
exact_int@1
false
0.729661
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":93,"total_tokens":157}
{"decode_s":5.8839,"latency_source":"measured","prefill_s":0.9667,"tokens_per_second":10.877,"wall_clock_s":6.8505}
To find out how many bottles Kavya has now, we can break down the problem into two steps: 1. Subtract the number of bottles used from the initial total. 2. Add the number of new bottles given by her friend. Let's do this step-by-step: Initial number of bottles = 82
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Kavya had 82 bottles, then used 9 of them. A friend later gave Kavya 25 more bottles. How many bottles does Kavya have now?
98
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
29f480f93fabcdaf9e346c88#r0
arithmetic-2-0003
arithmetic
2
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:58:17+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
f7de7ede5e3c12e6a4ac955b
aggregate
null
0
3,000
25
majority_vote
false
exact@majority
false
0.666667
vote_agreement
{"completion_tokens":64,"per_sample_completion_tokens":[64,64,64],"prompt_tokens":93,"total_completion_tokens_all_samples":192,"total_tokens":157,"total_tokens_all_samples":471}
{"decode_s":5.8839,"latency_source":"measured","prefill_s":0.9667,"tokens_per_second":10.877,"wall_clock_s":6.8505}
First, let's break down the problem step-by-step: 1. Initially, Kavya had 82 bottles. 2. She used 9 bottles. 3. Then, she received 25 more bottles from a friend. Now, let's calculate how many bottles Kavya has after these transactions:
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Kavya had 82 bottles, then used 9 of them. A friend later gave Kavya 25 more bottles. How many bottles does Kavya have now?
98
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
f7de7ede5e3c12e6a4ac955b#r0
arithmetic-3-0006
arithmetic
3
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:58:38+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
419aeb07bc0135f6b851bd3c
sample
0
0
3,000
105
last_line
false
exact_int@1
false
0.800018
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":86,"total_tokens":150}
{"decode_s":6.0762,"latency_source":"measured","prefill_s":0.9458,"tokens_per_second":10.533,"wall_clock_s":7.022}
First, let's calculate the total number of candles Ivo initially has: \[ \text{Total number of candles} = \text{Number of candles per box} \times \text{Number of boxes} = 7 \times 15 = 105 \] Next, we subtract
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Each box contains 7 candles. Ivo buys 15 boxes and then donates 16 candles. How many candles does Ivo have left?
89
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
419aeb07bc0135f6b851bd3c#r0
arithmetic-3-0006
arithmetic
3
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:58:38+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
45b37bd324aa7c4b9ff700e7
sample
1
0
3,000
1
last_line
false
exact_int@1
false
0.694184
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":86,"total_tokens":150}
{"decode_s":6.0762,"latency_source":"measured","prefill_s":0.9458,"tokens_per_second":10.533,"wall_clock_s":7.022}
To solve this problem, we can follow these steps: 1. Calculate the total number of candles before any were donated. 2. Subtract the number of candles donated from the total to find out how many candles are left. Let's perform the calculation: Step 1: Total candles before donation = Number of boxes Γ— Number
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Each box contains 7 candles. Ivo buys 15 boxes and then donates 16 candles. How many candles does Ivo have left?
89
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
45b37bd324aa7c4b9ff700e7#r0
arithmetic-3-0006
arithmetic
3
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:58:38+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
d09b3f445b35cae6cce72827
sample
2
0
3,000
7
last_line
false
exact_int@1
false
0.822087
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":86,"total_tokens":150}
{"decode_s":6.0762,"latency_source":"measured","prefill_s":0.9458,"tokens_per_second":10.533,"wall_clock_s":7.022}
To solve this problem, let's break it down step-by-step: 1. **Calculate the total number of candles in the 15 boxes**: - Each box contains 7 candles. - So, for 15 boxes, the total number of candles is \(15 \times 7 =
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Each box contains 7 candles. Ivo buys 15 boxes and then donates 16 candles. How many candles does Ivo have left?
89
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
d09b3f445b35cae6cce72827#r0
arithmetic-3-0006
arithmetic
3
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:58:38+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
de2b12c0c6daba0a7ce511a6
aggregate
null
0
3,000
1
majority_vote
false
exact@majority
false
0.333333
vote_agreement
{"completion_tokens":64,"per_sample_completion_tokens":[64,64,64],"prompt_tokens":86,"total_completion_tokens_all_samples":192,"total_tokens":150,"total_tokens_all_samples":450}
{"decode_s":6.0762,"latency_source":"measured","prefill_s":0.9458,"tokens_per_second":10.533,"wall_clock_s":7.022}
To solve this problem, we can follow these steps: 1. Calculate the total number of candles before any were donated. 2. Subtract the number of candles donated from the total to find out how many candles are left. Let's perform the calculation: Step 1: Total candles before donation = Number of boxes Γ— Number
0
null
null
null
Solve the problem. Show your reasoning briefly, then write the final line as: ANSWER: <number> Problem: Each box contains 7 candles. Ivo buys 15 boxes and then donates 16 candles. How many candles does Ivo have left?
89
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
de2b12c0c6daba0a7ce511a6#r0
code_reasoning-1-0000
code_reasoning
1
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:58:59+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
34f78512f0fe95785874759a
sample
0
0
3,000
3
last_line
false
exact_int@1
false
0.665926
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":91,"total_tokens":155}
{"decode_s":6.3011,"latency_source":"measured","prefill_s":1.1204,"tokens_per_second":10.157,"wall_clock_s":7.4215}
First, let's trace the program step-by-step: 1. Define an empty list `xs`. 2. Assign the values `[9, 7, 9, 6, 2]` to `xs`. 3. Calculate the product of elements at indices 2 and 3 in `xs`. The
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python xs = [9, 7, 9, 6, 2] print(xs[2] * 3) ```
27
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
34f78512f0fe95785874759a#r0
code_reasoning-1-0000
code_reasoning
1
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:58:59+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
eb3bdd73f616f414947019c2
sample
1
0
3,000
1
last_line
false
exact_int@1
false
0.512053
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":91,"total_tokens":155}
{"decode_s":6.3011,"latency_source":"measured","prefill_s":1.1204,"tokens_per_second":10.157,"wall_clock_s":7.4215}
The given code snippet is attempting to print the product of every second element in the list `xs` that contains two elements. However, there's an issue with how the multiplication operation is being performed. Let's break down the code: 1. **List Creation**: The list comprehension creates a new list called `xs`,
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python xs = [9, 7, 9, 6, 2] print(xs[2] * 3) ```
27
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
eb3bdd73f616f414947019c2#r0
code_reasoning-1-0000
code_reasoning
1
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:58:59+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
0c5779ac3211c7297ae20e92
sample
2
0
3,000
1
last_line
false
exact_int@1
false
0.527421
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":91,"total_tokens":155}
{"decode_s":6.3011,"latency_source":"measured","prefill_s":1.1204,"tokens_per_second":10.157,"wall_clock_s":7.4215}
To trace the program provided by you, I will follow these steps: 1. **Identify what each section of code does**: - The first part initializes an empty list `xs` with some integers. - The second part creates another list `xs` using the initial values from `xs`. -
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python xs = [9, 7, 9, 6, 2] print(xs[2] * 3) ```
27
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
0c5779ac3211c7297ae20e92#r0
code_reasoning-1-0000
code_reasoning
1
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:58:59+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
c8eff0f999706d25c4f00a5c
aggregate
null
0
3,000
1
majority_vote
false
exact@majority
false
0.666667
vote_agreement
{"completion_tokens":64,"per_sample_completion_tokens":[64,64,64],"prompt_tokens":91,"total_completion_tokens_all_samples":192,"total_tokens":155,"total_tokens_all_samples":465}
{"decode_s":6.3011,"latency_source":"measured","prefill_s":1.1204,"tokens_per_second":10.157,"wall_clock_s":7.4215}
The given code snippet is attempting to print the product of every second element in the list `xs` that contains two elements. However, there's an issue with how the multiplication operation is being performed. Let's break down the code: 1. **List Creation**: The list comprehension creates a new list called `xs`,
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python xs = [9, 7, 9, 6, 2] print(xs[2] * 3) ```
27
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
c8eff0f999706d25c4f00a5c#r0
code_reasoning-2-0003
code_reasoning
2
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:59:23+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
2d304ecdabe08aabaee6a684
sample
0
0
3,000
3
last_line
false
exact_int@1
false
0.581395
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":91,"total_tokens":155}
{"decode_s":6.9028,"latency_source":"measured","prefill_s":1.3643,"tokens_per_second":9.272,"wall_clock_s":8.2671}
First, let's trace the program step-by-step: 1. **Initialization**: We start with an empty string `s`. 2. **Extracting Substring**: - The variable `s` is set to "hcjfabeeiffe". - To extract the substring from index 3 to index
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python s = 'hcjfabeeiffe' sub = s[3:8] print(len(set(sub)) + len(sub)) ```
9
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
2d304ecdabe08aabaee6a684#r0
code_reasoning-2-0003
code_reasoning
2
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:59:23+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
f1e43cedf3050dd72dde3560
sample
1
0
3,000
1
last_line
false
exact_int@1
false
0.715256
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":91,"total_tokens":155}
{"decode_s":6.9028,"latency_source":"measured","prefill_s":1.3643,"tokens_per_second":9.272,"wall_clock_s":8.2671}
To trace the given Python code and determine the single integer it prints, we need to break down the logic step-by-step: 1. **Initialization**: ```python s = 'hcjfabeeiffe' ``` This initializes the string `s` with the value `'hcjfabeeiffe
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python s = 'hcjfabeeiffe' sub = s[3:8] print(len(set(sub)) + len(sub)) ```
9
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
f1e43cedf3050dd72dde3560#r0
code_reasoning-2-0003
code_reasoning
2
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:59:23+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
2e23aa64baafe3bc28dc7881
sample
2
0
3,000
5
last_line
false
exact_int@1
false
0.448702
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":91,"total_tokens":155}
{"decode_s":6.9028,"latency_source":"measured","prefill_s":1.3643,"tokens_per_second":9.272,"wall_clock_s":8.2671}
To trace the program provided by you, I will follow these steps: 1. Understand what each part of the code does. 2. Identify where variables are being used. 3. Trace through the nested loops and conditionals. 4. Determine which operation results in an integer. 5. Print out the result. Let's
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python s = 'hcjfabeeiffe' sub = s[3:8] print(len(set(sub)) + len(sub)) ```
9
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
2e23aa64baafe3bc28dc7881#r0
code_reasoning-2-0003
code_reasoning
2
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:59:23+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
99bcf955f595ec76d2d5cf27
aggregate
null
0
3,000
1
majority_vote
false
exact@majority
false
0.333333
vote_agreement
{"completion_tokens":64,"per_sample_completion_tokens":[64,64,64],"prompt_tokens":91,"total_completion_tokens_all_samples":192,"total_tokens":155,"total_tokens_all_samples":465}
{"decode_s":6.9028,"latency_source":"measured","prefill_s":1.3643,"tokens_per_second":9.272,"wall_clock_s":8.2671}
To trace the given Python code and determine the single integer it prints, we need to break down the logic step-by-step: 1. **Initialization**: ```python s = 'hcjfabeeiffe' ``` This initializes the string `s` with the value `'hcjfabeeiffe
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python s = 'hcjfabeeiffe' sub = s[3:8] print(len(set(sub)) + len(sub)) ```
9
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
99bcf955f595ec76d2d5cf27#r0
code_reasoning-3-0006
code_reasoning
3
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:59:46+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
a03b513bca041b1f53ad26da
sample
0
0
3,000
3
last_line
false
exact_int@1
false
0.674296
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":134,"total_tokens":198}
{"decode_s":7.0073,"latency_source":"measured","prefill_s":1.1398,"tokens_per_second":9.133,"wall_clock_s":8.1472}
First, let's trace the program step-by-step: 1. **Initialization**: We start with an empty dictionary `counts`. 2. **Iteration through list elements**: - The list contains integers from `[1, 1, 3, 3, 2, 2, 0, 3
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python xs = [1, 1, 3, 3, 2, 2, 0, 3] counts = {} for v in xs: counts[v] = counts.get(v, 0) + 1 print(counts.get(4, 0) * 10 + len(counts)) ```
4
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
a03b513bca041b1f53ad26da#r0
code_reasoning-3-0006
code_reasoning
3
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:59:46+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
c288a9a322206cf33888b8ad
sample
1
0
3,000
3
last_line
false
exact_int@1
false
0.537936
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":134,"total_tokens":198}
{"decode_s":7.0073,"latency_source":"measured","prefill_s":1.1398,"tokens_per_second":9.133,"wall_clock_s":8.1472}
### Step-by-Step Analysis #### Initialization of Lists: Firstly, we initialize two lists - `xs` containing `[1, 1, 3, 3, 2, 2, 0, 3]`, which contains all unique elements from the input list. Next, we create an
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python xs = [1, 1, 3, 3, 2, 2, 0, 3] counts = {} for v in xs: counts[v] = counts.get(v, 0) + 1 print(counts.get(4, 0) * 10 + len(counts)) ```
4
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
c288a9a322206cf33888b8ad#r0
code_reasoning-3-0006
code_reasoning
3
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:59:46+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
4049b9c8833f6b0f674c1334
sample
2
0
3,000
3
last_line
false
exact_int@1
false
0.762253
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":134,"total_tokens":198}
{"decode_s":7.0073,"latency_source":"measured","prefill_s":1.1398,"tokens_per_second":9.133,"wall_clock_s":8.1472}
To trace the program manually, let's break down each part step-by-step: 1. **Initialization**: ```python xs = [1, 1, 3, 3, 2, 2, 0, 3] counts = {} ``` - `xs
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python xs = [1, 1, 3, 3, 2, 2, 0, 3] counts = {} for v in xs: counts[v] = counts.get(v, 0) + 1 print(counts.get(4, 0) * 10 + len(counts)) ```
4
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
4049b9c8833f6b0f674c1334#r0
code_reasoning-3-0006
code_reasoning
3
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T17:59:46+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
3d29ba362cd3f68e23dfaa27
aggregate
null
0
3,000
3
majority_vote
false
exact@majority
false
1
vote_agreement
{"completion_tokens":64,"per_sample_completion_tokens":[64,64,64],"prompt_tokens":134,"total_completion_tokens_all_samples":192,"total_tokens":198,"total_tokens_all_samples":594}
{"decode_s":7.0073,"latency_source":"measured","prefill_s":1.1398,"tokens_per_second":9.133,"wall_clock_s":8.1472}
First, let's trace the program step-by-step: 1. **Initialization**: We start with an empty dictionary `counts`. 2. **Iteration through list elements**: - The list contains integers from `[1, 1, 3, 3, 2, 2, 0, 3
0
null
null
null
Trace the program below by hand and determine the single integer it prints. Reason step by step, then write the final line as: ANSWER: <integer> ```python xs = [1, 1, 3, 3, 2, 2, 0, 3] counts = {} for v in xs: counts[v] = counts.get(v, 0) + 1 print(counts.get(4, 0) * 10 + len(counts)) ```
4
int
procedural
CC-BY-4.0
none_by_construction
gen-1.0
3d29ba362cd3f68e23dfaa27#r0
logic-1-0000
logic
1
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T18:00:09+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
db1cd0a6168cd35774814e93
sample
0
0
3,000
{"Ben": 3}
last_line
false
exact_assignment@1
false
0.442941
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":105,"total_tokens":169}
{"decode_s":6.6951,"latency_source":"measured","prefill_s":1.0293,"tokens_per_second":9.559,"wall_clock_s":7.7244}
Firstly, let's understand why we assign individuals to positions given the constraints: 1. Each person must be assigned a unique position. 2. ChloΓ« and Ana cannot be adjacent. 3. Ben should be immediately before Chloe. From these observations, we can deduce the following assignments: - Since Chloe and Ana
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe. Positions: 1, 2, 3 (each used exactly once). Constraints: - Chloe and Ana are not in adjacent positions. - Ben is immediately before Chloe.
{"Ana": 1, "Ben": 2, "Chloe": 3}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
db1cd0a6168cd35774814e93#r0
logic-1-0000
logic
1
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T18:00:09+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
06aacdfa4405cf65bdea2e71
sample
1
0
3,000
null
raw_tail
false
exact_assignment@1
true
0.483935
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":105,"total_tokens":169}
{"decode_s":6.6951,"latency_source":"measured","prefill_s":1.0293,"tokens_per_second":9.559,"wall_clock_s":7.7244}
### Reasoning: To solve this problem, we need to arrange four people into three distinct positions while ensuring that no two adjacent people are in adjacent positions. Let's start with the first constraint: "Chloe and Ana cannot be in adjacent positions." Given the constraints, the only way for them to be adjacent ...
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe. Positions: 1, 2, 3 (each used exactly once). Constraints: - Chloe and Ana are not in adjacent positions. - Ben is immediately before Chloe.
{"Ana": 1, "Ben": 2, "Chloe": 3}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
06aacdfa4405cf65bdea2e71#r0
logic-1-0000
logic
1
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T18:00:09+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
25dd4a30c8e5cc4a6c8be69c
sample
2
0
3,000
null
last_line
false
exact_assignment@1
true
0.576332
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":105,"total_tokens":169}
{"decode_s":6.6951,"latency_source":"measured","prefill_s":1.0293,"tokens_per_second":9.559,"wall_clock_s":7.7244}
### Step-by-Step Assignment Given the constraints that: - Each person must be assigned to exactly one distinct position. - The positions are numbered from 1 to 3. We need to assign the names Ana, Ben, and Chloe to these positions. Let's break down the process: 1. **Chloe
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe. Positions: 1, 2, 3 (each used exactly once). Constraints: - Chloe and Ana are not in adjacent positions. - Ben is immediately before Chloe.
{"Ana": 1, "Ben": 2, "Chloe": 3}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
25dd4a30c8e5cc4a6c8be69c#r0
logic-1-0000
logic
1
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T18:00:09+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
ceda2c7f8c9bf07ff43e38d7
aggregate
null
0
3,000
{"Ben": 3}
majority_vote
false
exact@majority
false
0.333333
vote_agreement
{"completion_tokens":64,"per_sample_completion_tokens":[64,64,64],"prompt_tokens":105,"total_completion_tokens_all_samples":192,"total_tokens":169,"total_tokens_all_samples":507}
{"decode_s":6.6951,"latency_source":"measured","prefill_s":1.0293,"tokens_per_second":9.559,"wall_clock_s":7.7244}
Firstly, let's understand why we assign individuals to positions given the constraints: 1. Each person must be assigned a unique position. 2. ChloΓ« and Ana cannot be adjacent. 3. Ben should be immediately before Chloe. From these observations, we can deduce the following assignments: - Since Chloe and Ana
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe. Positions: 1, 2, 3 (each used exactly once). Constraints: - Chloe and Ana are not in adjacent positions. - Ben is immediately before Chloe.
{"Ana": 1, "Ben": 2, "Chloe": 3}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
ceda2c7f8c9bf07ff43e38d7#r0
logic-2-0003
logic
2
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T18:00:31+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
eae6901475d30b69f0e6889b
sample
0
0
3,000
{"Ana": 5}
last_line
false
exact_assignment@1
false
0.795403
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":136,"total_tokens":200}
{"decode_s":6.5327,"latency_source":"measured","prefill_s":1.1773,"tokens_per_second":9.797,"wall_clock_s":7.71}
First, let's identify the constraints: 1. Diego and Ana cannot be in adjacent positions. 2. Chloe is immediately before Diego. 3. Ben is not in position 4. 4. Ben and Chloe are not in adjacent positions. 5. Ana is immediately before Chloe. Now, we need to assign each person
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe, Diego. Positions: 1, 2, 3, 4 (each used exactly once). Constraints: - Diego and Ana are not in adjacent positions. - Chloe is immediately before Die...
{"Ana": 2, "Ben": 1, "Chloe": 3, "Diego": 4}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
eae6901475d30b69f0e6889b#r0
logic-2-0003
logic
2
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T18:00:31+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
d8393aefe6d3b00214bfce09
sample
1
0
3,000
null
last_line
false
exact_assignment@1
true
0.426405
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":136,"total_tokens":200}
{"decode_s":6.5327,"latency_source":"measured","prefill_s":1.1773,"tokens_per_second":9.797,"wall_clock_s":7.71}
### Step-by-step Reasoning: #### Analysis of Constraints: 1. **Diego** and **Ana** cannot be adjacent, meaning they must be placed at either ends or in positions with no spaces between them. 2. **Chloe** must be immediately before **Diego**, so her position is **1**
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe, Diego. Positions: 1, 2, 3, 4 (each used exactly once). Constraints: - Diego and Ana are not in adjacent positions. - Chloe is immediately before Die...
{"Ana": 2, "Ben": 1, "Chloe": 3, "Diego": 4}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
d8393aefe6d3b00214bfce09#r0
logic-2-0003
logic
2
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T18:00:31+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
543eec1c935c7952e26cf41e
sample
2
0
3,000
null
last_line
false
exact_assignment@1
true
0.444682
self_certainty_mean_logprob
{"completion_tokens":64,"prompt_tokens":136,"total_tokens":200}
{"decode_s":6.5327,"latency_source":"measured","prefill_s":1.1773,"tokens_per_second":9.797,"wall_clock_s":7.71}
### Step-by-Step Assignment Given the constraints, we need to place people in distinct positions such that no two people share the same position, and some individuals must be placed next to each other while adhering to specific rules. Here's the assignment with reasoning: 1. **Diego** must be in position **
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe, Diego. Positions: 1, 2, 3, 4 (each used exactly once). Constraints: - Diego and Ana are not in adjacent positions. - Chloe is immediately before Die...
{"Ana": 2, "Ben": 1, "Chloe": 3, "Diego": 4}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
543eec1c935c7952e26cf41e#r0
logic-2-0003
logic
2
sc3_cap64
self_consistency
Qwen/Qwen2.5-0.5B-Instruct
7ae557604adf67be50417f59c2c2f167def9a775
{"chat_template":"user_turn","prompt_variant":"cot","stop":["\n\n\n"],"temperature":0.8,"top_k":null,"top_p":0.95}
{"max_new_tokens":64,"max_tool_calls":0,"n_samples":3,"prefix_nested":false,"wall_clock_s":null}
n_samples=3: 3 independent samples are drawn per task at the stated temperature/top_p with max_new_tokens=64 per sample; the answer is selected by the stated aggregation rule. Per-sample token cap is held fixed. max_new_tokens=64 (held fixed per sample).
samples
[]
2026-11-16T18:00:31+00:00
ttcbench-1.0.0
{"captured_at":"2026-11-16T17:51:56+00:00","cpu_count":12,"cuda_available":false,"device":"cpu","machine":"AMD64","numpy":"2.4.6","pandas":"3.1.1","platform":"Windows-10-10.0.26300-SP0","processor":"AMD64 Family 25 Model 80 Stepping 0, AuthenticAMD","python":"3.11.9","ram_avail_gb":2.73,"ram_load_pct":83,"ram_total_gb"...
v1.0
1049fa9d4c8c4961c4f0a372
aggregate
null
0
3,000
{"Ana": 5}
majority_vote
false
exact@majority
false
0.333333
vote_agreement
{"completion_tokens":64,"per_sample_completion_tokens":[64,64,64],"prompt_tokens":136,"total_completion_tokens_all_samples":192,"total_tokens":200,"total_tokens_all_samples":600}
{"decode_s":6.5327,"latency_source":"measured","prefill_s":1.1773,"tokens_per_second":9.797,"wall_clock_s":7.71}
First, let's identify the constraints: 1. Diego and Ana cannot be in adjacent positions. 2. Chloe is immediately before Diego. 3. Ben is not in position 4. 4. Ben and Chloe are not in adjacent positions. 5. Ana is immediately before Chloe. Now, we need to assign each person
0
null
null
null
Assign each person to exactly one distinct position. Reason step by step, then write the final line as: ANSWER: Name=position, Name=position, ... People: Ana, Ben, Chloe, Diego. Positions: 1, 2, 3, 4 (each used exactly once). Constraints: - Diego and Ana are not in adjacent positions. - Chloe is immediately before Die...
{"Ana": 2, "Ben": 1, "Chloe": 3, "Diego": 4}
map
procedural
CC-BY-4.0
none_by_construction
gen-1.0
1049fa9d4c8c4961c4f0a372#r0
End of preview. Expand in Data Studio

Test-Time Compute Bench

A deployment-aware benchmark for inference-time computation. It asks: how do accuracy, calibration, run-to-run consistency, latency and cost change as a model is given more inference compute, and when does additional compute stop paying for itself?

The dataset's distinguishing feature is not the tasks. It is that every recorded outcome is tied to the compute budget that produced it, the resources it consumed, and a deterministic, independently audited verdict.

Contents

File Rows What it is
data/tasks.parquet 150 The evaluation instances
data/runs.parquet see card footer One row per outcome, with its budget and resources
data/outcomes.parquet 111 runs joined to tasks: every promised field on one row
data/tasks_twin_heldout.parquet 150 A second, never-released split from a different seed, for the memorisation protocol
data/verifier_audit_per_task.csv 150 Per-task false-accept / false-reject probe results
data/verifier_audit_summary.json β€” Aggregate verifier audit
data/contamination_report.json β€” Duplicate, template-overlap and n-gram checks
data/analysis/ β€” Arm summary, domain/difficulty tables, paired statistics, summary.json
verify/verify.py β€” Standalone, dependency-free verifier for the three answer types

tasks and runs are deliberately normalised, because one task is evaluated at several budgets under several policies. If you only want a flat table, use the outcomes config: it is runs left-joined to tasks on task_id, so a single row carries the task ID, domain, difficulty, exact prompt, allowed tools, compute budget and its definition, model checkpoint, sampling configuration, final answer, verified result, token usage, latency and repeat identifier. The repeat_id column there is run_id#r<repeat_index>.

Task families

domain What the model must do Gold label produced by
arithmetic Multi-step word problems, integer answers computing the answer from the drawn parameters
code_reasoning Predict the integer printed by a short Python program executing the generated program
logic Assign people to unique positions under constraints a hidden permutation, with uniqueness proven by exhaustive enumeration

Difficulty tiers 1–5 control operation count, construct complexity, and (for logic) the number of entities. Each family has 50 instances, ten per tier.

Fields: tasks

Field Type Description
task_id string Stable id, {domain}-{difficulty}-{index}
domain string arithmetic | code_reasoning | logic
difficulty int8 Intended difficulty tier, 1–5
prompt string Exact prompt shown to the model, verbatim
allowed_tools JSON list Tools the model may invoke; empty means none
answer JSON string Canonical gold answer
answer_type string int | map | list | str β€” the checker contract
prompt_template_version string Versioned template identifier
generator, generator_seed, generator_params string/int/JSON Reproduces this exact instance
source string procedural for all instances
source_license string CC-BY-4.0
contamination_risk string none_by_construction (instance level)
content_hash string SHA-256 prefix of the normalised prompt
split string heldout

Fields: runs

Every field below is present on every row. The field that makes analysis possible is compute_budget together with budget_definition: the operational meaning of the budget is stored as prose, so a row is interpretable without consulting the paper.

Group Fields
Identity run_id, task_id, domain, difficulty, config_id, strategy
Model model_checkpoint, model_revision
Sampling sampling_config (temperature, top_p, top_k, stop, chat template), seed
Budget compute_budget (max_new_tokens, n_samples, max_tool_calls, wall_clock_s, prefix_nested), budget_definition, budget_units
Tools allowed_tools, tool_calls_made
Outcome final_answer, extraction_method, verified_result, verifier_name, parse_error, correct
Uncertainty confidence, confidence_source
Resources token_usage, latency (wall clock, prefill, decode, tokens/s, measured vs estimated), cost_usd, environment
Design row_kind (final|sample|aggregate), sample_index, repeat_index
Provenance timestamp, harness_version, prompt_template_version, error

raw_output is retained as evidence, not as truth. Correctness is decided only by the deterministic verifier acting on the final answer. Generated reasoning is never used as ground truth and is not a faithful explanation of the model's internal computation.

Verification

Three answer types, three exact checkers: integer equality after format normalisation, assignment-map equality, and list equality. Extraction follows a fixed cascade (ANSWER: marker β†’ \boxed{} β†’ "final answer is" β†’ last numeric line), and failures to extract are recorded separately from disagreements as parse_error, so harness error is not silently attributed to the model.

verify/verify.py reproduces the scores without this repository's package:

from verify import verify
v = verify("Reasoning...\nANSWER: 42", gold=42, answer_type="int")
assert v["verified_result"] is True

Verifier audit

Exact matching is not obviously correct, so it is measured in both directions on every task:

  • False accepts β€” designed wrong answers (off-by-one, off-by-ten, sign flip, digit transposition, order swap, halving, one-step truncation, no-marker). A checker that accepts these silently caps the accuracy of any sampling-based policy.
  • False rejects β€” semantics-preserving surface variants (ANSWER: 42, 42., $42$, comma groupinG, \boxed{42}, boldface, 42.0, trailing unit words, A=2 vs A: 2 vs "A is in position 2").

Rates are in data/verifier_audit_summary.json, with per-probe detail in the CSV. The probe sets are designed, not exhaustive: this measures performance against probes we could think of, not against the space of all wrong answers.

Reproducing the released verdicts

The standalone checker in verify/verify.py was run over every row of data/runs.parquet and reproduces the stored verified_result on 111/111 rows, so the released scores can be recomputed without the harness.

One provenance repair was needed to reach that state and is disclosed rather than hidden: the first pilot run wrote aggregate self-consistency and best-of-$N$ rows with raw_output taken from sample 0 while the committed answer came from the winning sample. The verdicts were always computed from the parsed answers and are unchanged; only the evidence text was wrong. Six aggregate rows were repaired from the per-sample rows (which are released alongside them) by scripts/migrate_aggregate_evidence.py, and the harness now stores the selected sample's text. Tool-arm rows are verified from executed stdout, which is why final_answer rather than raw_output is the authoritative answer field there.

Task source, licence and contamination

  • Source. Every instance is synthesised by a seeded generator in this repository. No third-party text, no scraped benchmark, no human annotation. Consequently the licence is uniform: task text CC-BY-4.0, code MIT.
  • Instance-level contamination: none by construction. No instance exists in any public corpus before release, and instances are reproducible from a seed, so a fresh split can always be generated.
  • Template-level contamination: present and documented. The templates are ordinary arithmetic/code/logic patterns that models have certainly seen. This is quantified in contamination_report.json as the framing fraction of each prompt and, optionally, as 13-gram overlap against a supplied corpus. A model may memorise a template rather than an instance, and this dataset cannot rule that out.
  • Memorisation protocol. data/tasks_twin_heldout.parquet is a second split from a different seed. Comparing accuracy on the released split against the twin is the recommended test for instance-level memorisation; see the paper's Appendix.

Intended use

Research on inference-time compute, budget allocation, calibration and selective prediction; teaching cost-aware evaluation. Not intended as a leaderboard of model capability: 150 short, exactly-checkable tasks are a measurement instrument, not a measure of general reasoning.

Known limitations

  1. Short, exactly-checkable answers only. Long-form or partially checkable tasks are out of scope by design.
  2. Exact match is brittle by design; the false-reject rate quantifies the residue.
  3. runs comes from a small pilot on one 0.5B model on a CPU-only host. It demonstrates the schema and the analysis, not a compute optimum. Widen it before drawing comparative conclusions.
  4. Absolute latencies describe the recorded host under load; the environment column is mandatory for any latency claim.
  5. Confidence is a token-probability proxy and is expected to be miscalibrated.

Citation

@misc{ttcbench2026,
  title  = {Test-Time Compute Bench: A Deployment-Aware Benchmark for Inference-Time Compute},
  author = {Hafeez, Fahad},
  year   = {2026},
  note   = {Dataset and evaluation harness},
  url    = {https://huggingface.co/datasets/fadhafeezofficial/test-time-compute-bench}
}
Downloads last month
68