Add dummy PIE C++ oracle seed dataset

ORACLE_WRITER_INSTRUCTIONS.md

@@ -0,0 +1,19 @@
+# Oracle Writer Instructions
+
+You are given rows from `data/oracle_seed.jsonl`.
+
+For each row:
+
+1. Read `messages` as the exact chat input. `prompt` is only a flattened fallback for non-chat tooling.
+2. Produce an optimized C++20 program that preserves exactly the same stdin/stdout behavior as `source_code`.
+3. Return the original input `messages` unchanged, then append exactly one assistant message with:
+   - one `<reasoning>...</reasoning>` block;
+   - one fenced `cpp` code block;
+   - no extra text before, between, or after those two parts.
+4. Compile the generated program with the row's `compile.command`.
+5. Run all visible tests from `visible_tests`.
+6. Fill the `verification` object truthfully.
+
+Do not return partial-credit rows for training. If a solution does not compile or does not pass tests, mark it as failed and do not call it oracle data.
+
+The expected output JSONL shape is shown in `data/oracle_return_example.jsonl`.

README.md

@@ -0,0 +1,106 @@
+---
+license: mit
+task_categories:
+- text-generation
+- reinforcement-learning
+language:
+- en
+- code
+pretty_name: Dummy PIE C++ Oracle Seed
+size_categories:
+- n<1K
+configs:
+- config_name: default
+  data_files:
+  - split: oracle_seed
+    path: data/oracle_seed.jsonl
+---
+
+# 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.
+
+## 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.
+
+## Required Oracle Return Format
+
+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.
+
+For each input row, return one SFT-ready chat row. Copy the input `messages` exactly, then append the assistant answer:
+
+```json
+{
+  "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:
+
+1. One `<reasoning>...</reasoning>` block.
+2. One fenced C++ block starting with ```` ```cpp ````.
+3. No extra prose outside those two parts.
+
+The output format is intentionally fixed. Only the input prompt style varies.
+
+## 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.
+
+## Loading Locally
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("json", data_files="data/oracle_seed.jsonl", split="train")
+print(ds[0])
+```

data/oracle_return_example.jsonl

@@ -0,0 +1 @@
+{"task_id": "dummy_pie_cpp_0001_sum_even", "messages": [{"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 optimized C++20 program. Do not include any other text."}, {"role": "user", "content": "Task: optimize this correct but intentionally inefficient C++20 program. Keep the same input and output behavior.\n\nOriginal program:\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>\nusing namespace std;\nint 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;i++){for(int j=0;j<=i;j++){if(i==j && a[j]%2==0) ans+=a[j];}}cout<<ans<<\"\\n\";}\n```\n\nVisible tests:\nsample_1 stdin:\n```text\n5\n1 2 3 4 6\n```\nExpected stdout:\n```text\n12\n```"}, {"role": "assistant", "content": "<reasoning>The nested loop only contributes when i equals j, so the program is just summing even elements once. Replace the quadratic loop with one linear pass over the array while preserving the same input and output format.</reasoning>\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>\nusing namespace std;\nint main(){\n    ios::sync_with_stdio(false);\n    cin.tie(nullptr);\n    int n;\n    cin >> n;\n    long long ans = 0;\n    for(int i = 0; i < n; ++i){\n        long long x;\n        cin >> x;\n        if(x % 2 == 0) ans += x;\n    }\n    cout << ans << '\\n';\n    return 0;\n}\n```"}], "verification": {"compile_ok": true, "all_visible_tests_pass": true, "all_hidden_tests_pass": null, "score": 1.0, "runtime_ms": null, "notes": "Example return row. Real rows should include actual verifier evidence if available."}}

data/oracle_seed.jsonl

@@ -0,0 +1,5 @@
+{"task_id": "dummy_pie_cpp_0001_sum_even", "source": "dummy_pie_cpp", "split": "oracle_seed", "language": "cpp20", "prompt_template_id": "system_contract_user_problem", "source_code": "#include <iostream>\n#include <vector>\n#include <string>\n#include <unordered_set>\n#include <unordered_map>\n#include <climits>\n#include <algorithm>\nusing namespace std;\nint 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;i++){for(int j=0;j<=i;j++){if(i==j && a[j]%2==0) ans+=a[j];}}cout<<ans<<\"\\n\";}", "visible_tests": [{"name": "sample_1", "stdin": "5\n1 2 3 4 6\n", "stdout": "12\n"}], "public_checker": {"type": "exact_stdout", "strip_trailing_whitespace": true}, "compile": {"command": "g++ -std=c++20 -O2 -pipe main.cpp -o main", "timeout_sec": 20}, "run": {"timeout_sec": 2, "memory_mb": 512}, "constraints": {"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"}, "metadata": {"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"}, "messages": [{"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 optimized C++20 program. Do not include any other text."}, {"role": "user", "content": "Task: optimize this correct but intentionally inefficient C++20 program. Keep the same input and output behavior.\n\nOriginal program:\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>\nusing namespace std;\nint 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;i++){for(int j=0;j<=i;j++){if(i==j && a[j]%2==0) ans+=a[j];}}cout<<ans<<\"\\n\";}\n```\n\nVisible tests:\nsample_1 stdin:\n```text\n5\n1 2 3 4 6\n```\nExpected stdout:\n```text\n12\n```"}], "prompt": "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 include any other text.\n\nUSER: Task: optimize this correct but intentionally inefficient C++20 program. Keep the same input and output behavior.\n\nOriginal program:\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>\nusing namespace std;\nint 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;i++){for(int j=0;j<=i;j++){if(i==j && a[j]%2==0) ans+=a[j];}}cout<<ans<<\"\\n\";}\n```\n\nVisible tests:\nsample_1 stdin:\n```text\n5\n1 2 3 4 6\n```\nExpected stdout:\n```text\n12\n```"}
+{"task_id": "dummy_pie_cpp_0002_prefix_queries", "source": "dummy_pie_cpp", "split": "oracle_seed", "language": "cpp20", "prompt_template_id": "user_only_full_instruction", "source_code": "#include <iostream>\n#include <vector>\n#include <string>\n#include <unordered_set>\n#include <unordered_map>\n#include <climits>\n#include <algorithm>\nusing namespace std;\nint 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>>l>>r;long long s=0;for(int i=1;i<=n;i++){if(l<=i && i<=r)s+=a[i];}cout<<s<<\"\\n\";}}", "visible_tests": [{"name": "sample_1", "stdin": "5 3\n2 4 6 8 10\n1 3\n2 5\n4 4\n", "stdout": "12\n28\n8\n"}], "public_checker": {"type": "exact_stdout", "strip_trailing_whitespace": true}, "compile": {"command": "g++ -std=c++20 -O2 -pipe main.cpp -o main", "timeout_sec": 20}, "run": {"timeout_sec": 2, "memory_mb": 512}, "constraints": {"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"}, "metadata": {"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"}, "messages": [{"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 behavior.\n\nOriginal program:\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>\nusing namespace std;\nint 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>>l>>r;long long s=0;for(int i=1;i<=n;i++){if(l<=i && i<=r)s+=a[i];}cout<<s<<\"\\n\";}}\n```\n\nVisible tests:\nsample_1 stdin:\n```text\n5 3\n2 4 6 8 10\n1 3\n2 5\n4 4\n```\nExpected stdout:\n```text\n12\n28\n8\n```"}], "prompt": "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.\n\nTask: optimize this correct but intentionally inefficient C++20 program. Keep the same input and output behavior.\n\nOriginal program:\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>\nusing namespace std;\nint 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>>l>>r;long long s=0;for(int i=1;i<=n;i++){if(l<=i && i<=r)s+=a[i];}cout<<s<<\"\\n\";}}\n```\n\nVisible tests:\nsample_1 stdin:\n```text\n5 3\n2 4 6 8 10\n1 3\n2 5\n4 4\n```\nExpected stdout:\n```text\n12\n28\n8\n```"}
+{"task_id": "dummy_pie_cpp_0003_count_pairs", "source": "dummy_pie_cpp", "split": "oracle_seed", "language": "cpp20", "prompt_template_id": "system_role_user_brief", "source_code": "#include <iostream>\n#include <vector>\n#include <string>\n#include <unordered_set>\n#include <unordered_map>\n#include <climits>\n#include <algorithm>\nusing namespace std;\nint 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 j=0;j<n;j++){if(i<j && a[i]+a[j]==k)ans++;}}cout<<ans<<\"\\n\";}", "visible_tests": [{"name": "sample_1", "stdin": "6 7\n1 6 2 5 3 4\n", "stdout": "3\n"}], "public_checker": {"type": "exact_stdout", "strip_trailing_whitespace": true}, "compile": {"command": "g++ -std=c++20 -O2 -pipe main.cpp -o main", "timeout_sec": 20}, "run": {"timeout_sec": 2, "memory_mb": 512}, "constraints": {"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"}, "metadata": {"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"}, "messages": [{"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 optimized C++20 program. Do not include any other text."}, {"role": "user", "content": "Make the following C++20 solution asymptotically faster if possible, while preserving the exact interface and outputs.\n\nTask: optimize this correct but intentionally inefficient C++20 program. Keep the same input and output behavior.\n\nOriginal program:\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>\nusing namespace std;\nint 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 j=0;j<n;j++){if(i<j && a[i]+a[j]==k)ans++;}}cout<<ans<<\"\\n\";}\n```\n\nVisible tests:\nsample_1 stdin:\n```text\n6 7\n1 6 2 5 3 4\n```\nExpected stdout:\n```text\n3\n```"}], "prompt": "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 include any other text.\n\nUSER: Make the following C++20 solution asymptotically faster if possible, while preserving the exact interface and outputs.\n\nTask: optimize this correct but intentionally inefficient C++20 program. Keep the same input and output behavior.\n\nOriginal program:\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>\nusing namespace std;\nint 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 j=0;j<n;j++){if(i<j && a[i]+a[j]==k)ans++;}}cout<<ans<<\"\\n\";}\n```\n\nVisible tests:\nsample_1 stdin:\n```text\n6 7\n1 6 2 5 3 4\n```\nExpected stdout:\n```text\n3\n```"}
+{"task_id": "dummy_pie_cpp_0004_first_repeated", "source": "dummy_pie_cpp", "split": "oracle_seed", "language": "cpp20", "prompt_template_id": "system_contract_structured_user_spec", "source_code": "#include <iostream>\n#include <vector>\n#include <string>\n#include <unordered_set>\n#include <unordered_map>\n#include <climits>\n#include <algorithm>\nusing namespace std;\nint 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 seen=false;for(int j=0;j<i;j++){if(s[j]==s[i])seen=true;}if(seen){ans=s[i];break;}}cout<<ans<<\"\\n\";}", "visible_tests": [{"name": "sample_1", "stdin": "6\nred blue green blue red yellow\n", "stdout": "blue\n"}], "public_checker": {"type": "exact_stdout", "strip_trailing_whitespace": true}, "compile": {"command": "g++ -std=c++20 -O2 -pipe main.cpp -o main", "timeout_sec": 20}, "run": {"timeout_sec": 2, "memory_mb": 512}, "constraints": {"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"}, "metadata": {"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"}, "messages": [{"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: reduce runtime while preserving behavior\n  checker: exact stdout after trimming trailing whitespace\n  task_id: dummy_pie_cpp_0004_first_repeated\n\nsource_code:\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>\nusing namespace std;\nint 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 seen=false;for(int j=0;j<i;j++){if(s[j]==s[i])seen=true;}if(seen){ans=s[i];break;}}cout<<ans<<\"\\n\";}\n```\n\nvisible_tests:\nsample_1 stdin:\n```text\n6\nred blue green blue red yellow\n```\nExpected stdout:\n```text\nblue\n```"}], "prompt": "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.\n\nUSER: optimization_request:\n  language: C++20\n  objective: reduce runtime while preserving behavior\n  checker: exact stdout after trimming trailing whitespace\n  task_id: dummy_pie_cpp_0004_first_repeated\n\nsource_code:\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>\nusing namespace std;\nint 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 seen=false;for(int j=0;j<i;j++){if(s[j]==s[i])seen=true;}if(seen){ans=s[i];break;}}cout<<ans<<\"\\n\";}\n```\n\nvisible_tests:\nsample_1 stdin:\n```text\n6\nred blue green blue red yellow\n```\nExpected stdout:\n```text\nblue\n```"}
+{"task_id": "dummy_pie_cpp_0005_matrix_row_max", "source": "dummy_pie_cpp", "split": "oracle_seed", "language": "cpp20", "prompt_template_id": "user_natural_language_with_inline_contract", "source_code": "#include <iostream>\n#include <vector>\n#include <string>\n#include <unordered_set>\n#include <unordered_map>\n#include <climits>\n#include <algorithm>\nusing namespace std;\nint 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++)cin>>a[i][j];for(int i=0;i<n;i++){int best=INT_MIN;for(int j=0;j<m;j++){for(int k=0;k<m;k++){if(k==j)best=max(best,a[i][k]);}}cout<<best<<(i+1==n?'\\n':' ');} }", "visible_tests": [{"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"}], "public_checker": {"type": "exact_stdout", "strip_trailing_whitespace": true}, "compile": {"command": "g++ -std=c++20 -O2 -pipe main.cpp -o main", "timeout_sec": 20}, "run": {"timeout_sec": 2, "memory_mb": 512}, "constraints": {"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"}, "metadata": {"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"}, "messages": [{"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>\nusing namespace std;\nint 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++)cin>>a[i][j];for(int i=0;i<n;i++){int best=INT_MIN;for(int j=0;j<m;j++){for(int k=0;k<m;k++){if(k==j)best=max(best,a[i][k]);}}cout<<best<<(i+1==n?'\\n':' ');} }\n```\n\nTry it on this visible test before returning it:\nsample_1 stdin:\n```text\n3 4\n1 9 2 3\n4 5 6 7\n-3 -8 -1 -2\n```\nExpected stdout:\n```text\n9 7 -1\n```\n\nAnswer format: 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."}], "prompt": "USER: 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>\nusing namespace std;\nint 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++)cin>>a[i][j];for(int i=0;i<n;i++){int best=INT_MIN;for(int j=0;j<m;j++){for(int k=0;k<m;k++){if(k==j)best=max(best,a[i][k]);}}cout<<best<<(i+1==n?'\\n':' ');} }\n```\n\nTry it on this visible test before returning it:\nsample_1 stdin:\n```text\n3 4\n1 9 2 3\n4 5 6 7\n-3 -8 -1 -2\n```\nExpected stdout:\n```text\n9 7 -1\n```\n\nAnswer format: 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."}

schema/oracle_return.schema.json

@@ -0,0 +1,79 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Dummy PIE C++ Oracle Return Row",
+  "type": "object",
+  "required": [
+    "task_id",
+    "messages",
+    "verification"
+  ],
+  "properties": {
+    "task_id": {
+      "type": "string"
+    },
+    "messages": {
+      "type": "array",
+      "minItems": 2,
+      "items": {
+        "type": "object",
+        "required": [
+          "role",
+          "content"
+        ],
+        "properties": {
+          "role": {
+            "type": "string",
+            "enum": [
+              "system",
+              "user",
+              "assistant"
+            ]
+          },
+          "content": {
+            "type": "string"
+          }
+        },
+        "additionalProperties": false
+      }
+    },
+    "verification": {
+      "type": "object",
+      "required": [
+        "compile_ok",
+        "all_visible_tests_pass",
+        "all_hidden_tests_pass",
+        "score",
+        "runtime_ms",
+        "notes"
+      ],
+      "properties": {
+        "compile_ok": {
+          "type": "boolean"
+        },
+        "all_visible_tests_pass": {
+          "type": "boolean"
+        },
+        "all_hidden_tests_pass": {
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
+        "score": {
+          "type": "number"
+        },
+        "runtime_ms": {
+          "type": [
+            "number",
+            "null"
+          ]
+        },
+        "notes": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false
+}

schema/oracle_seed.schema.json

@@ -0,0 +1,176 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Dummy PIE C++ Oracle Seed Row",
+  "type": "object",
+  "required": [
+    "task_id",
+    "source",
+    "split",
+    "language",
+    "prompt_template_id",
+    "messages",
+    "prompt",
+    "source_code",
+    "visible_tests",
+    "public_checker",
+    "compile",
+    "run",
+    "constraints",
+    "metadata"
+  ],
+  "properties": {
+    "task_id": {
+      "type": "string"
+    },
+    "source": {
+      "type": "string"
+    },
+    "split": {
+      "type": "string",
+      "const": "oracle_seed"
+    },
+    "language": {
+      "type": "string",
+      "const": "cpp20"
+    },
+    "prompt_template_id": {
+      "type": "string"
+    },
+    "messages": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": [
+          "role",
+          "content"
+        ],
+        "properties": {
+          "role": {
+            "type": "string",
+            "enum": [
+              "system",
+              "user"
+            ]
+          },
+          "content": {
+            "type": "string"
+          }
+        },
+        "additionalProperties": false
+      }
+    },
+    "prompt": {
+      "type": "string"
+    },
+    "source_code": {
+      "type": "string"
+    },
+    "visible_tests": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": [
+          "name",
+          "stdin",
+          "stdout"
+        ],
+        "properties": {
+          "name": {
+            "type": "string"
+          },
+          "stdin": {
+            "type": "string"
+          },
+          "stdout": {
+            "type": "string"
+          }
+        },
+        "additionalProperties": false
+      }
+    },
+    "public_checker": {
+      "type": "object",
+      "required": [
+        "type",
+        "strip_trailing_whitespace"
+      ],
+      "properties": {
+        "type": {
+          "type": "string",
+          "const": "exact_stdout"
+        },
+        "strip_trailing_whitespace": {
+          "type": "boolean"
+        }
+      },
+      "additionalProperties": false
+    },
+    "compile": {
+      "type": "object",
+      "required": [
+        "command",
+        "timeout_sec"
+      ],
+      "properties": {
+        "command": {
+          "type": "string"
+        },
+        "timeout_sec": {
+          "type": "number"
+        }
+      },
+      "additionalProperties": false
+    },
+    "run": {
+      "type": "object",
+      "required": [
+        "timeout_sec",
+        "memory_mb"
+      ],
+      "properties": {
+        "timeout_sec": {
+          "type": "number"
+        },
+        "memory_mb": {
+          "type": "number"
+        }
+      },
+      "additionalProperties": false
+    },
+    "constraints": {
+      "type": "object",
+      "required": [
+        "assistant_format",
+        "must_preserve_io",
+        "must_compile",
+        "must_pass_visible_tests",
+        "target"
+      ],
+      "properties": {
+        "assistant_format": {
+          "type": "string",
+          "const": "one_reasoning_block_then_one_cpp_fence"
+        },
+        "must_preserve_io": {
+          "type": "boolean"
+        },
+        "must_compile": {
+          "type": "boolean"
+        },
+        "must_pass_visible_tests": {
+          "type": "boolean"
+        },
+        "target": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false
+    },
+    "metadata": {
+      "type": "object"
+    }
+  },
+  "additionalProperties": false
+}