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 |
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=2vsA: 2vs "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.jsonas 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.parquetis 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
- Short, exactly-checkable answers only. Long-form or partially checkable tasks are out of scope by design.
- Exact match is brittle by design; the false-reject rate quantifies the residue.
runscomes 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.- Absolute latencies describe the recorded host under load; the
environmentcolumn is mandatory for any latency claim. - 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