Datasets:

TokenBender
/

dummy-pie-cpp-oracle-seed

task_id string	source string	split string	language string	prompt_template_id string	source_code string	visible_tests list	public_checker dict	compile dict	run dict	constraints dict	metadata dict	messages list	prompt string
dummy_pie_cpp_0001_sum_even	dummy_pie_cpp	oracle_seed	cpp20	system_contract_user_problem	#include <iostream> #include <vector> #include <string> #include <unordered_set> #include <unordered_map> #include <climits> #include <algorithm> using namespace std; int main(){ios::sync_with_stdio(false);cin.tie(nullptr);int n;cin>>n;vector<long long>a(n);for(int i=0;i<n;i++)cin>>a[i];long long ans=0;for(int i=0;i<n;...	[ { "name": "sample_1", "stdin": "5\n1 2 3 4 6\n", "stdout": "12\n" } ]	{ "type": "exact_stdout", "strip_trailing_whitespace": true }	{ "command": "g++ -std=c++20 -O2 -pipe main.cpp -o main", "timeout_sec": 20 }	{ "timeout_sec": 2, "memory_mb": 512 }	{ "assistant_format": "one_reasoning_block_then_one_cpp_fence", "must_preserve_io": true, "must_compile": true, "must_pass_visible_tests": true, "target": "optimize runtime without changing outputs" }	{ "problem_id": "dummy_sum_even", "baseline_complexity": "O(n^2) due to redundant nested loop", "expected_better_complexity": "O(n)", "hidden_tests_policy": "not_in_seed", "oracle_acceptance": "full mark only" }	[ { "role": "system", "content": "You are an expert C++20 performance optimizer. Preserve stdin/stdout behavior exactly. Prefer simple, readable algorithmic improvements over micro-optimizations. Return exactly one <reasoning>...</reasoning> block followed by exactly one fenced ```cpp code block containing an...	SYSTEM: You are an expert C++20 performance optimizer. Preserve stdin/stdout behavior exactly. Prefer simple, readable algorithmic improvements over micro-optimizations. Return exactly one <reasoning>...</reasoning> block followed by exactly one fenced ```cpp code block containing an optimized C++20 program. Do not inc...
dummy_pie_cpp_0002_prefix_queries	dummy_pie_cpp	oracle_seed	cpp20	user_only_full_instruction	#include <iostream> #include <vector> #include <string> #include <unordered_set> #include <unordered_map> #include <climits> #include <algorithm> using namespace std; int main(){ios::sync_with_stdio(false);cin.tie(nullptr);int n,q;cin>>n>>q;vector<long long>a(n+1);for(int i=1;i<=n;i++)cin>>a[i];while(q--){int l,r;cin>>...	[ { "name": "sample_1", "stdin": "5 3\n2 4 6 8 10\n1 3\n2 5\n4 4\n", "stdout": "12\n28\n8\n" } ]	{ "type": "exact_stdout", "strip_trailing_whitespace": true }	{ "command": "g++ -std=c++20 -O2 -pipe main.cpp -o main", "timeout_sec": 20 }	{ "timeout_sec": 2, "memory_mb": 512 }	{ "assistant_format": "one_reasoning_block_then_one_cpp_fence", "must_preserve_io": true, "must_compile": true, "must_pass_visible_tests": true, "target": "optimize runtime without changing outputs" }	{ "problem_id": "dummy_prefix_queries", "baseline_complexity": "O(nq) range sums", "expected_better_complexity": "O(n+q) with prefix sums", "hidden_tests_policy": "not_in_seed", "oracle_acceptance": "full mark only" }	[ { "role": "user", "content": "Return exactly one <reasoning>...</reasoning> block followed by exactly one fenced ```cpp code block containing an optimized C++20 program. Do not include any other text.\n\nTask: optimize this correct but intentionally inefficient C++20 program. Keep the same input and output ...	USER: Return exactly one <reasoning>...</reasoning> block followed by exactly one fenced ```cpp code block containing an optimized C++20 program. Do not include any other text. Task: optimize this correct but intentionally inefficient C++20 program. Keep the same input and output behavior. Original program: ```cpp #i...
dummy_pie_cpp_0003_count_pairs	dummy_pie_cpp	oracle_seed	cpp20	system_role_user_brief	#include <iostream> #include <vector> #include <string> #include <unordered_set> #include <unordered_map> #include <climits> #include <algorithm> using namespace std; int main(){ios::sync_with_stdio(false);cin.tie(nullptr);int n,k;cin>>n>>k;vector<int>a(n);for(int&i:a)cin>>i;long long ans=0;for(int i=0;i<n;i++){for(int...	[ { "name": "sample_1", "stdin": "6 7\n1 6 2 5 3 4\n", "stdout": "3\n" } ]	{ "type": "exact_stdout", "strip_trailing_whitespace": true }	{ "command": "g++ -std=c++20 -O2 -pipe main.cpp -o main", "timeout_sec": 20 }	{ "timeout_sec": 2, "memory_mb": 512 }	{ "assistant_format": "one_reasoning_block_then_one_cpp_fence", "must_preserve_io": true, "must_compile": true, "must_pass_visible_tests": true, "target": "optimize runtime without changing outputs" }	{ "problem_id": "dummy_count_pairs", "baseline_complexity": "O(n^2) pair enumeration", "expected_better_complexity": "O(n) average with hash map or O(n log n) with sorting", "hidden_tests_policy": "not_in_seed", "oracle_acceptance": "full mark only" }	[ { "role": "system", "content": "You are an expert C++20 performance optimizer. Preserve stdin/stdout behavior exactly. Prefer simple, readable algorithmic improvements over micro-optimizations. Return exactly one <reasoning>...</reasoning> block followed by exactly one fenced ```cpp code block containing an...	SYSTEM: You are an expert C++20 performance optimizer. Preserve stdin/stdout behavior exactly. Prefer simple, readable algorithmic improvements over micro-optimizations. Return exactly one <reasoning>...</reasoning> block followed by exactly one fenced ```cpp code block containing an optimized C++20 program. Do not inc...
dummy_pie_cpp_0004_first_repeated	dummy_pie_cpp	oracle_seed	cpp20	system_contract_structured_user_spec	#include <iostream> #include <vector> #include <string> #include <unordered_set> #include <unordered_map> #include <climits> #include <algorithm> using namespace std; int main(){ios::sync_with_stdio(false);cin.tie(nullptr);int n;cin>>n;vector<string>s(n);for(auto&x:s)cin>>x;string ans="NONE";for(int i=0;i<n;i++){bool s...	[ { "name": "sample_1", "stdin": "6\nred blue green blue red yellow\n", "stdout": "blue\n" } ]	{ "type": "exact_stdout", "strip_trailing_whitespace": true }	{ "command": "g++ -std=c++20 -O2 -pipe main.cpp -o main", "timeout_sec": 20 }	{ "timeout_sec": 2, "memory_mb": 512 }	{ "assistant_format": "one_reasoning_block_then_one_cpp_fence", "must_preserve_io": true, "must_compile": true, "must_pass_visible_tests": true, "target": "optimize runtime without changing outputs" }	{ "problem_id": "dummy_first_repeated", "baseline_complexity": "O(n^2) previous-item scan", "expected_better_complexity": "O(n) average with unordered_set", "hidden_tests_policy": "not_in_seed", "oracle_acceptance": "full mark only" }	[ { "role": "system", "content": "Return exactly one <reasoning>...</reasoning> block followed by exactly one fenced ```cpp code block containing an optimized C++20 program. Do not include any other text." }, { "role": "user", "content": "optimization_request:\n language: C++20\n objective: redu...	SYSTEM: Return exactly one <reasoning>...</reasoning> block followed by exactly one fenced ```cpp code block containing an optimized C++20 program. Do not include any other text. USER: optimization_request: language: C++20 objective: reduce runtime while preserving behavior checker: exact stdout after trimming t...
dummy_pie_cpp_0005_matrix_row_max	dummy_pie_cpp	oracle_seed	cpp20	user_natural_language_with_inline_contract	#include <iostream> #include <vector> #include <string> #include <unordered_set> #include <unordered_map> #include <climits> #include <algorithm> using namespace std; int main(){ios::sync_with_stdio(false);cin.tie(nullptr);int n,m;cin>>n>>m;vector<vector<int>>a(n,vector<int>(m));for(int i=0;i<n;i++)for(int j=0;j<m;j++)...	[ { "name": "sample_1", "stdin": "3 4\n1 9 2 3\n4 5 6 7\n-3 -8 -1 -2\n", "stdout": "9 7 -1\n" } ]	{ "type": "exact_stdout", "strip_trailing_whitespace": true }	{ "command": "g++ -std=c++20 -O2 -pipe main.cpp -o main", "timeout_sec": 20 }	{ "timeout_sec": 2, "memory_mb": 512 }	{ "assistant_format": "one_reasoning_block_then_one_cpp_fence", "must_preserve_io": true, "must_compile": true, "must_pass_visible_tests": true, "target": "optimize runtime without changing outputs" }	{ "problem_id": "dummy_matrix_row_max", "baseline_complexity": "O(nm^2) redundant row maximum scan", "expected_better_complexity": "O(nm)", "hidden_tests_policy": "not_in_seed", "oracle_acceptance": "full mark only" }	[ { "role": "user", "content": "Can you make this C++ program faster without changing what it reads or prints? Please keep it C++20.\n\nProgram:\n```cpp\n#include <iostream>\n#include <vector>\n#include <string>\n#include <unordered_set>\n#include <unordered_map>\n#include <climits>\n#include <algorithm>\nusi...	USER: Can you make this C++ program faster without changing what it reads or prints? Please keep it C++20. Program: ```cpp #include <iostream> #include <vector> #include <string> #include <unordered_set> #include <unordered_map> #include <climits> #include <algorithm> using namespace std; int main(){ios::sync_with_std...

Dummy PIE C++ Oracle Seed

This is a tiny 5-row Hugging Face dataset skeleton for generating oracle SFT data for a PIE-style C++ optimization task.

The rows are intentionally synthetic. They define the exact shape we want for real PIE C++ tasks without exposing or depending on private prepared artifacts.

The goal is to give an oracle-data writer a clean contract:

read a C++ optimization task;
produce one verified optimized solution;
return the result in chat/SFT format;
include enough verification metadata for us to decide whether the row is safe to train on.

This dataset is not a benchmark and should not be used to claim model quality. It is a format sample for building the real oracle dataset.

Repository Layout

dummy-pie-cpp-oracle-seed
├── README.md
├── ORACLE_WRITER_INSTRUCTIONS.md
├── data/
│   ├── oracle_seed.jsonl
│   └── oracle_return_example.jsonl
└── schema/
    ├── oracle_seed.schema.json
    └── oracle_return.schema.json

`README.md`

This file. It explains the dataset purpose, the row contract, the expected return format, and the intended reading order.

`ORACLE_WRITER_INSTRUCTIONS.md`

The short handoff file for the person or agent generating oracle solutions. Send them this file first. It tells them how to read each row, what answer format to produce, and what verification fields to fill.

`data/oracle_seed.jsonl`

The actual 5-row seed dataset. Each line is one prompt-only C++ optimization task.

Important fields:

messages: the canonical chat input. Use this as the real prompt.
prompt_template_id: the input style used by the row.
prompt: a flattened fallback for tools that cannot consume chat messages.
source_code: the original inefficient but correct C++20 program.
visible_tests: public tests included in the task.
compile: compiler command and timeout.
run: runtime and memory limits.
constraints: required assistant output contract.
metadata: problem notes and expected optimization direction.

`data/oracle_return_example.jsonl`

One solved example showing the expected output from an oracle writer. The returned row copies the original input messages and appends one assistant message with the optimized C++ answer.

`schema/oracle_seed.schema.json`

JSON Schema for validating input seed rows before sending them to an oracle writer.

`schema/oracle_return.schema.json`

JSON Schema for validating returned oracle rows before running the stronger local verifier.

What The Oracle Writer Receives

Each row is a prompt-only optimization task. The canonical input is messages, not prompt.

task_id: stable row identifier.
messages: the exact chat input to give the model or oracle writer.
prompt_template_id: which input style this row uses.
prompt: flattened fallback for loaders that do not support chat messages.
source_code: the unoptimized but correct C++20 program.
visible_tests: public tests included in the prompt.
public_checker: how visible outputs should be compared.
compile: expected compiler command and timeout.
run: expected runtime and memory limits.
constraints: required assistant output contract.
metadata: problem notes and expected optimization direction.

Prompt Diversity

The 5 seed rows intentionally vary the input style so the model does not overfit to one prompt wording:

system message with output contract, user message with task;
user-only full instruction;
system role instruction, brief user request;
structured user spec with a system contract;
natural user request with inline answer-format instruction.

The output format is intentionally fixed. Only the input prompt style varies.

Required Oracle Return Format

For each input row, return one SFT-ready chat row. Copy the input messages exactly, then append the assistant answer:

{
  "task_id": "dummy_pie_cpp_0001_sum_even",
  "messages": [
    {
      "role": "system",
      "content": "same system message from the seed row, if present"
    },
    {
      "role": "user",
      "content": "same user message from the seed row"
    },
    {
      "role": "assistant",
      "content": "<reasoning>Short optimization explanation.</reasoning>\n```cpp\n// optimized C++20 code\n```"
    }
  ],
  "verification": {
    "compile_ok": true,
    "all_visible_tests_pass": true,
    "all_hidden_tests_pass": null,
    "score": 1.0,
    "runtime_ms": null,
    "notes": "Verified locally by oracle writer."
  }
}

The assistant message must contain exactly:

One <reasoning>...</reasoning> block.
One fenced C++ block starting with ```cpp.
No extra prose outside those two parts.

End-To-End Flow

oracle_seed row
  -> oracle writer reads messages
  -> oracle writer writes optimized C++ answer
  -> oracle writer compiles and runs visible tests
  -> oracle writer returns oracle_return row
  -> local verifier checks format, compile, tests, and score
  -> only full-mark verified rows become SFT data

Validation Rule For Real Training

Returned oracle rows should not be used for SFT until our local verifier confirms:

output format is valid;
generated C++ compiles;
visible tests pass;
hidden/generated tests pass when available;
reward or grade is full mark.

The verification object in returned rows is useful metadata, but it is not enough by itself. It should be treated as a claim from the oracle writer. The final training set should be built only after our own verifier confirms the row.

Intended SFT Conversion

Once a returned row is verified, the messages array is already in SFT-ready chat form:

[
  {"role": "system", "content": "...optional system instruction..."},
  {"role": "user", "content": "...C++ optimization task..."},
  {"role": "assistant", "content": "<reasoning>...</reasoning>\n```cpp\n...\n```"}
]

Rows that fail compilation, fail tests, have invalid formatting, or receive partial credit should be excluded from SFT.

Boundary

This dummy dataset only specifies the data interface. It does not include:

real PIE C++ train/eval rows;
hidden tests;
a full verifier implementation;
model training scripts;
claims about model improvement.

Loading Locally

from datasets import load_dataset

ds = load_dataset("json", data_files="data/oracle_seed.jsonl", split="train")
print(ds[0])

Downloads last month: 11

Total file size:

34.9 kB

Dummy PIE C++ Oracle Seed

Repository Layout

README.md

ORACLE_WRITER_INSTRUCTIONS.md

data/oracle_seed.jsonl

data/oracle_return_example.jsonl

schema/oracle_seed.schema.json

schema/oracle_return.schema.json

Recommended Reading Order