Update dataset

data/test-00000-of-00001.json

@@ -252,10 +252,10 @@
 {"problem_id": "vector_addition/2_20", "category": "research", "statement": "Vector Addition Problem - Medium Vectors (2^20)\n================================================\n\nProblem Setting\n---------------\nDesign and optimize high-performance Triton kernels for vector addition on GPU with medium vectors (1,048,576 elements). This problem focuses on implementing efficient element-wise addition for typical workloads.\n\nThe challenge involves optimizing:\n- **Memory access patterns**: Efficient loading and storing of vector data\n- **Block sizing**: Optimal block sizes for GPU execution\n- **Memory bandwidth**: Maximizing throughput for simple arithmetic operations\n- **Performance benchmarking**: Achieving speedup over PyTorch baseline\n\nThis variant tests performance on medium vectors (2^20 = 1,048,576 elements = 4 MB per vector).\n\nTarget\n------\n- **Primary**: Maximize bandwidth (GB/s) over PyTorch baseline (higher is better)\n- **Secondary**: Ensure correctness\n- **Tertiary**: Minimize kernel launch overhead\n\nAPI Specification\n-----------------\nImplement a `Solution` class that returns a Triton kernel implementation:\n\n```python\nclass Solution:\n    def solve(self, spec_path: str = None) -> dict:\n        \"\"\"\n        Returns a dict with either:\n        - {\"code\": \"python_code_string\"}\n        - {\"program_path\": \"path/to/kernel.py\"}\n        \"\"\"\n        # Your implementation\n        pass\n```\n\nYour kernel implementation must provide:\n\n```python\nimport torch\nimport triton\nimport triton.language as tl\n\ndef add(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\n    \"\"\"\n    Element-wise addition of two vectors.\n    \n    Args:\n        x: Input tensor of shape (1048576,)\n        y: Input tensor of shape (1048576,)\n    \n    Returns:\n        Output tensor of shape (1048576,) with x + y\n    \"\"\"\n    pass\n```\n\nAPI Usage Notes\n---------------\n- The evaluator looks for an `add` function in the module namespace\n- Function must handle vector size of exactly 1,048,576 elements\n- Must use Triton JIT compilation for kernel definition\n- Should optimize for memory bandwidth\n- Input tensors are guaranteed to be contiguous and same size\n\nScoring (0-100)\n---------------\nPerformance is measured against CPU baseline and PyTorch GPU baseline:\n\n```\ntarget = max(2.0 * (pytorch_bandwidth / cpu_bandwidth), 1.0)\nscore = ((custom_bandwidth / cpu_bandwidth - 1.0) / (target - 1.0)) * 100\n\nWhere:\n- custom_bandwidth = your solution's bandwidth\n- cpu_bandwidth = naive CPU baseline bandwidth\n- pytorch_bandwidth = PyTorch GPU baseline bandwidth\n- target = 2x PyTorch performance vs CPU (normalized to custom vs CPU)\n\nScore is clamped to [0, 100] range\n```\n\n- 0 points = CPU baseline performance (custom/cpu = 1x)\n- 50 points = Halfway between CPU baseline and 2x PyTorch performance\n- 100 points = 2x PyTorch GPU performance vs CPU (custom/cpu = 2 * pytorch/cpu)\n\nEvaluation Details\n------------------\n- Tested on vector size: 2^20 = 1,048,576 elements\n- Performance measured in GB/s (bandwidth)\n- Correctness verified with tolerance: rtol=1e-5, atol=1e-8\n- Performance measured using median execution time across 5 samples\n- Requires CUDA backend and GPU support\n", "config": "dependencies:\n  uv_project: resources\ntag: hpc\nruntime:\n  environment: \"Triton 3.2.0 with CUDA 12.2 (triton-tlx image)\"\n  docker:\n    image: andylizf/triton-tlx:tlx-nv-cu122\n    gpu: true\n"}
 {"problem_id": "vector_addition/2_24", "category": "research", "statement": "Vector Addition Problem - Large Vectors (2^24)\n===============================================\n\nProblem Setting\n---------------\nDesign and optimize high-performance Triton kernels for vector addition on GPU with large vectors (16,777,216 elements). This problem focuses on implementing efficient element-wise addition for high-throughput workloads.\n\nThe challenge involves optimizing:\n- **Memory bandwidth**: Maximizing throughput for large vectors\n- **Memory access patterns**: Efficient loading and storing of vector data\n- **Block sizing**: Optimal block sizes for large vectors\n- **Performance benchmarking**: Achieving speedup over PyTorch baseline\n\nThis variant tests performance on large vectors (2^24 = 16,777,216 elements = 64 MB per vector).\n\nTarget\n------\n- **Primary**: Maximize bandwidth (GB/s) over PyTorch baseline (higher is better)\n- **Secondary**: Minimize kernel launch overhead\n- **Tertiary**: Ensure correctness\n\nAPI Specification\n-----------------\nImplement a `Solution` class that returns a Triton kernel implementation:\n\n```python\nclass Solution:\n    def solve(self, spec_path: str = None) -> dict:\n        \"\"\"\n        Returns a dict with either:\n        - {\"code\": \"python_code_string\"}\n        - {\"program_path\": \"path/to/kernel.py\"}\n        \"\"\"\n        # Your implementation\n        pass\n```\n\nYour kernel implementation must provide:\n\n```python\nimport torch\nimport triton\nimport triton.language as tl\n\ndef add(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\n    \"\"\"\n    Element-wise addition of two vectors.\n    \n    Args:\n        x: Input tensor of shape (16777216,)\n        y: Input tensor of shape (16777216,)\n    \n    Returns:\n        Output tensor of shape (16777216,) with x + y\n    \"\"\"\n    pass\n```\n\nAPI Usage Notes\n---------------\n- The evaluator looks for an `add` function in the module namespace\n- Function must handle vector size of exactly 16,777,216 elements\n- Must use Triton JIT compilation for kernel definition\n- Should optimize for small vector performance and launch overhead\n- Input tensors are guaranteed to be contiguous and same size\n\nScoring (0-100)\n---------------\nPerformance is measured against CPU baseline and PyTorch GPU baseline:\n\n```\ntarget = max(2.0 * (pytorch_bandwidth / cpu_bandwidth), 1.0)\nscore = ((custom_bandwidth / cpu_bandwidth - 1.0) / (target - 1.0)) * 100\n\nWhere:\n- custom_bandwidth = your solution's bandwidth\n- cpu_bandwidth = naive CPU baseline bandwidth\n- pytorch_bandwidth = PyTorch GPU baseline bandwidth\n- target = 2x PyTorch performance vs CPU (normalized to custom vs CPU)\n\nScore is clamped to [0, 100] range\n```\n\n- 0 points = CPU baseline performance (custom/cpu = 1x)\n- 50 points = Halfway between CPU baseline and 2x PyTorch performance\n- 100 points = 2x PyTorch GPU performance vs CPU (custom/cpu = 2 * pytorch/cpu)\n\nEvaluation Details\n------------------\n- Tested on vector size: 2^24 = 16,777,216 elements\n- Performance measured in GB/s (bandwidth)\n- Correctness verified with tolerance: rtol=1e-5, atol=1e-8\n- Performance measured using median execution time across 5 samples\n- Requires CUDA backend and GPU support\n", "config": "dependencies:\n  uv_project: resources\ndatasets: []\ntag: hpc\nruntime:\n  docker:\n    image: andylizf/triton-tlx:tlx-nv-cu122\n    gpu: true\n  environment: \"Triton 3.2.0 with CUDA 12.2 (triton-tlx image)\"\n"}
 {"problem_id": "vector_addition/2_28", "category": "research", "statement": "Vector Addition Problem - Very Large Vectors (2^28)\n==============================================\n\nProblem Setting\n---------------\nDesign and optimize high-performance Triton kernels for vector addition on GPU with very large vectors (268,435,456 elements). This problem focuses on implementing efficient element-wise addition for maximum throughput scenarios.\n\nThe challenge involves optimizing:\n- **Memory access patterns**: Efficient loading and storing of large vector data\n- **Block sizing**: Optimal block sizes for large GPU workloads\n- **Memory bandwidth**: Maximizing throughput at scale\n- **Performance benchmarking**: Achieving speedup over PyTorch baseline\n\nThis variant tests performance on very large vectors (2^28 = 268,435,456 elements = 1 GB per vector). Requires ~3 GB GPU memory total.\n\nTarget\n------\n- **Primary**: Maximize bandwidth (GB/s) over PyTorch baseline (higher is better)\n- **Secondary**: Ensure correctness on large vectors\n- **Tertiary**: Minimize memory overhead\n\nAPI Specification\n-----------------\nImplement a `Solution` class that returns a Triton kernel implementation:\n\n```python\nclass Solution:\n    def solve(self, spec_path: str = None) -> dict:\n        \"\"\"\n        Returns a dict with either:\n        - {\"code\": \"python_code_string\"}\n        - {\"program_path\": \"path/to/kernel.py\"}\n        \"\"\"\n        # Your implementation\n        pass\n```\n\nYour kernel implementation must provide:\n\n```python\nimport torch\nimport triton\nimport triton.language as tl\n\ndef add(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\n    \"\"\"\n    Element-wise addition of two vectors.\n    \n    Args:\n        x: Input tensor of shape (268435456,)\n        y: Input tensor of shape (268435456,)\n    \n    Returns:\n        Output tensor of shape (268435456,) with x + y\n    \"\"\"\n    pass\n```\n\nAPI Usage Notes\n---------------\n- The evaluator looks for an `add` function in the module namespace\n- Function must handle vector size of exactly 268,435,456 elements\n- Must use Triton JIT compilation for kernel definition\n- Should optimize for maximum memory bandwidth at scale\n- Input tensors are guaranteed to be contiguous and same size\n- May cause OOM on GPUs with less than 3GB memory\n\nScoring (0-100)\n---------------\nPerformance is measured against CPU baseline and PyTorch GPU baseline:\n\n```\ntarget = max(2.0 * (pytorch_bandwidth / cpu_bandwidth), 1.0)\nscore = ((custom_bandwidth / cpu_bandwidth - 1.0) / (target - 1.0)) * 100\n\nWhere:\n- custom_bandwidth = your solution's bandwidth\n- cpu_bandwidth = naive CPU baseline bandwidth\n- pytorch_bandwidth = PyTorch GPU baseline bandwidth\n- target = 2x PyTorch performance vs CPU (normalized to custom vs CPU)\n\nScore is clamped to [0, 100] range\n```\n\n- 0 points = CPU baseline performance (custom/cpu = 1x)\n- 50 points = Halfway between CPU baseline and 2x PyTorch performance\n- 100 points = 2x PyTorch GPU performance vs CPU (custom/cpu = 2 * pytorch/cpu)\n\nEvaluation Details\n------------------\n- Tested on vector size: 2^28 = 268,435,456 elements\n- Performance measured in GB/s (bandwidth)\n- Correctness verified with tolerance: rtol=1e-5, atol=1e-8\n- Performance measured using median execution time across 5 samples\n- Requires CUDA backend and GPU support\n- Requires sufficient GPU memory (may OOM on smaller GPUs)\n", "config": "dependencies:\n  uv_project: resources\ndatasets: []\ntag: hpc\nruntime:\n  docker:\n    image: andylizf/triton-tlx:tlx-nv-cu122\n    gpu: true\n  environment: \"Triton 3.2.0 with CUDA 12.2 (triton-tlx image)\"\n"}
-{"problem_id": "bboplace_direct_iccad2015", "category": "2.0", "statement": "BBOPlace Direct ICCAD2015\n========================\n\nDirectly submit one JSON macro placement for a single BBOPlace ICCAD2015\ndesign: `superblue1`. The hidden judge evaluates the placement with the\noriginal BBOPlace-Bench MGO MP-HPWL evaluator.\n\nRuntime and resources\n---------------------\n\nYour final submission is a JSON file at `/app/solution.json`. You are encouraged\nto write Python programs, shell scripts, search loops, local parsers, or any\nother helper code in `/app` while working. Those programs may generate and\noverwrite `/app/solution.json` many times. Only the final JSON artifact is\ngraded.\n\nThe agent container provides:\n\n- 8 CPU cores\n- 16 GiB memory\n- 8 GiB storage\n- no GPU\n- Python 3 with NumPy available for local helper scripts\n- hidden benchmark data is not available in the agent workspace\n\nThe judge also runs on CPU only. Do not rely on CUDA, DREAMPlace, Ray, or GPU\nplacement libraries for scoring.\n\nSubmission format\n-----------------\n\nSubmit exactly one placement for `superblue1` by writing `/app/solution.json`.\nAfter your program writes the file, call `bash /app/submit.sh` to score that\nJSON. The JSON must use one of these forms:\n\n```json\n{\"placement\": [0.0, 0.0, \"...\"]}\n```\n\nor:\n\n```json\n{\"x\": [0.0, 0.0, \"...\"], \"y\": [0.0, 0.0, \"...\"]}\n```\n\nThe placement vector length must equal `dim = 2 * node_cnt`. The first\n`node_cnt` entries are x-grid coordinates and the remaining `node_cnt` entries\nare y-grid coordinates. Coordinates must be finite, with x in `[0, n_grid_x]`\nand y in `[0, n_grid_y]`. Only one placement is accepted.\n\nThe judge discloses public metadata through the iterative feedback path,\nincluding `dim`, `node_cnt`, `n_grid_x`, `n_grid_y`, and the baseline HPWL.\nThe netlist and evaluator source stay hidden in the judge image.\n\nScore\n-----\n\nThe objective is to minimize MP-HPWL for `superblue1`:\n\n`raw_score = 100 * (baseline_hpwl - candidate_hpwl) / baseline_hpwl`\n\n`score = max(0, raw_score)`\n\nThe baseline constant is from the BBOPlace-Bench report, Table V, `MGO + PSO`\nMP-HPWL. The paper reports values in units of `x10^5`; the judge stores the\nraw HPWL value relaxed by `1.2x`:\n\n- `superblue1`: `0.696e5`\n\nBoth iterative submissions and final verification evaluate this same single\ndesign. The submit helper may still save the best iterative JSON artifact and\nrerun it during final verification.\n", "config": "tag: optimization\nruntime:\n  language: json\n  timeout_seconds: 10800\n  environment: \"JSON placement for one hidden ICCAD2015 BBOPlace design\"\n  apt_packages:\n    - python3-numpy\n  docker:\n    image: ubuntu:24.04\n    judge_image: ghcr.io/frontiercs/frontiercs-bboplace-data:2026-06-ispd-iccad\nsubmission:\n  kind: file\n  path: /app/solution.json\nenvironment:\n  cpus: 8\n  memory_mb: 16384\n  storage_mb: 8192\n  build_timeout_seconds: 3600\n"}
-{"problem_id": "bboplace_direct_ispd2005", "category": "2.0", "statement": "BBOPlace Direct ISPD2005\n=======================\n\nDirectly submit one JSON macro placement for a single BBOPlace ISPD2005 design:\n`adaptec1`. The hidden judge evaluates the placement with the original\nBBOPlace-Bench MGO MP-HPWL evaluator.\n\nRuntime and resources\n---------------------\n\nYour final submission is a JSON file at `/app/solution.json`. You are encouraged\nto write Python programs, shell scripts, search loops, local parsers, or any\nother helper code in `/app` while working. Those programs may generate and\noverwrite `/app/solution.json` many times. Only the final JSON artifact is\ngraded.\n\nThe agent container provides:\n\n- 8 CPU cores\n- 16 GiB memory\n- 8 GiB storage\n- no GPU\n- Python 3 with NumPy available for local helper scripts\n- hidden benchmark data is not available in the agent workspace\n\nThe judge also runs on CPU only. Do not rely on CUDA, DREAMPlace, Ray, or GPU\nplacement libraries for scoring.\n\nSubmission format\n-----------------\n\nSubmit exactly one placement for `adaptec1` by writing `/app/solution.json`.\nAfter your program writes the file, call `bash /app/submit.sh` to score that\nJSON. The JSON must use one of these forms:\n\n```json\n{\"placement\": [0.0, 0.0, \"...\"]}\n```\n\nor:\n\n```json\n{\"x\": [0.0, 0.0, \"...\"], \"y\": [0.0, 0.0, \"...\"]}\n```\n\nThe placement vector length must equal `dim = 2 * node_cnt`. The first\n`node_cnt` entries are x-grid coordinates and the remaining `node_cnt` entries\nare y-grid coordinates. Coordinates must be finite, with x in `[0, n_grid_x]`\nand y in `[0, n_grid_y]`. Only one placement is accepted.\n\nThe judge discloses public metadata through the iterative feedback path,\nincluding `dim`, `node_cnt`, `n_grid_x`, `n_grid_y`, and the baseline HPWL.\nThe netlist and evaluator source stay hidden in the judge image.\n\nScore\n-----\n\nThe objective is to minimize MP-HPWL for `adaptec1`:\n\n`raw_score = 100 * (baseline_hpwl - candidate_hpwl) / baseline_hpwl`\n\n`score = max(0, raw_score)`\n\nThe baseline constant is from the BBOPlace-Bench report, Table III,\n`MGO + Vanilla-EA` MP-HPWL. The paper reports values in units of `x10^5`; the\njudge stores the raw HPWL value relaxed by `1.2x`:\n\n- `adaptec1`: `6.96e5`\n\nBoth iterative submissions and final verification evaluate this same single\ndesign. The submit helper may still save the best iterative JSON artifact and\nrerun it during final verification.\n", "config": "tag: optimization\nruntime:\n  language: json\n  timeout_seconds: 10800\n  environment: \"JSON placement for one hidden ISPD2005 BBOPlace design\"\n  apt_packages:\n    - python3-numpy\n  docker:\n    image: ubuntu:24.04\n    judge_image: ghcr.io/frontiercs/frontiercs-bboplace-data:2026-06-ispd-iccad\nsubmission:\n  kind: file\n  path: /app/solution.json\nenvironment:\n  cpus: 8\n  memory_mb: 16384\n  storage_mb: 8192\n  build_timeout_seconds: 3600\n"}
-{"problem_id": "bboplace_iccad2015", "category": "2.0", "statement": "BBOPlace ICCAD2015\n==================\n\nWrite a Python solution that proposes macro placements for the BBOPlace MGO\nformulation on the ICCAD2015 benchmark suite. The hidden judge evaluates your\nplacements with the original BBOPlace-Bench MP-HPWL evaluator.\n\nRuntime and resources\n---------------------\n\nYour solution runs in the main agent container with:\n\n- 8 CPU cores\n- 16 GiB memory\n- 8 GiB storage\n- no GPU\n- Python 3 with NumPy available\n- internet access may be available during the trial, but the benchmark data is\n  hidden and is not available in the agent workspace\n\nThe final verifier timeout is 10800 seconds. The judge also runs on CPU only.\nDo not rely on CUDA, DREAMPlace, Ray, or GPU placement libraries for scoring;\nthe official metric path used here is MGO with MP-HPWL.\n\nYour file must define one of:\n\n- `solve(info)`\n- `generate(info)`\n- `run(info)`\n- `CANDIDATES`, `CANDIDATE`, or `PLACEMENT`\n\nThe recommended interface is `solve(info)`. The judge calls it once per\nbenchmark. `info` contains:\n\n- `benchmark`: one of `superblue1`, `superblue3`, `superblue4`, `superblue5`,\n  `superblue7`, `superblue10`, `superblue16`, `superblue18`\n- `dim`: placement vector length\n- `node_cnt`: number of macros\n- `n_grid_x`, `n_grid_y`: MGO grid bounds\n- `max_candidates_per_submission`: 16\n- `baseline_hpwl`: the baseline HPWL used for scoring\n\nReturn either one placement vector of length `dim`, or a 2D list/array with up\nto 16 placement candidates. For MGO, the first `node_cnt` entries are x-grid\ncoordinates in `[0, n_grid_x]`, and the remaining `node_cnt` entries are y-grid\ncoordinates in `[0, n_grid_y]`.\n\nScore\n-----\n\nThe objective is to minimize MP-HPWL. For each benchmark:\n\n`raw_score = 100 * (baseline_hpwl - candidate_hpwl) / baseline_hpwl`\n\n`score = max(0, raw_score)`\n\nThe final score is the mean score over the eight ICCAD2015 benchmarks. The\nunbounded score is the mean raw score before the zero clip.\n\nDuring iterative agent submissions, `/app/submit.sh` gives quick feedback on\n`superblue1` only. The final verifier evaluates the full eight-benchmark suite.\nUse the quick feedback to debug general placement logic, not as the complete\nleaderboard score.\n\nThe submit helper saves the best quick-feedback artifact it has seen. During\nfinal verification, the verifier reruns both the current `/app/solution.py` and\nthat saved best iterative artifact on the full suite, then uses the better\nfull-suite score. A quick-feedback score is never used directly as the final\nreward.\n\nThe baseline constants are from the BBOPlace-Bench report, Table V,\n`MGO + PSO` MP-HPWL. The paper reports values in units of `x10^5`; the judge\nstores raw HPWL values relaxed by `1.2x`:\n\n- `superblue1`: `0.696e5`\n- `superblue3`: `1.824e5`\n- `superblue4`: `1.128e5`\n- `superblue5`: `4.512e5`\n- `superblue7`: `2.028e5`\n- `superblue10`: `0.648e5`\n- `superblue16`: `1.152e5`\n- `superblue18`: `0.576e5`\n\nThe benchmark data and evaluator source are only present in the judge image.\nThey are not available in the agent workspace.\n", "config": "tag: optimization\nruntime:\n  language: python\n  timeout_seconds: 10800\n  environment: \"Python solution returning BBOPlace MGO placement candidates; hidden ICCAD2015 judge data\"\n  apt_packages:\n    - python3-numpy\n  docker:\n    image: ubuntu:24.04\n    judge_image: ghcr.io/frontiercs/frontiercs-bboplace-data:2026-06-ispd-iccad\nenvironment:\n  cpus: 8\n  memory_mb: 16384\n  storage_mb: 8192\n  build_timeout_seconds: 3600\n"}
-{"problem_id": "bboplace_ispd2005", "category": "2.0", "statement": "BBOPlace ISPD2005\n=================\n\nWrite a Python solution that proposes macro placements for the BBOPlace MGO\nformulation on the ISPD2005 benchmark suite. The hidden judge evaluates your\nplacements with the original BBOPlace-Bench MP-HPWL evaluator.\n\nRuntime and resources\n---------------------\n\nYour solution runs in the main agent container with:\n\n- 8 CPU cores\n- 16 GiB memory\n- 8 GiB storage\n- no GPU\n- Python 3 with NumPy available\n- internet access may be available during the trial, but the benchmark data is\n  hidden and is not available in the agent workspace\n\nThe final verifier timeout is 10800 seconds. The judge also runs on CPU only.\nDo not rely on CUDA, DREAMPlace, Ray, or GPU placement libraries for scoring;\nthe official metric path used here is MGO with MP-HPWL.\n\nYour file must define one of:\n\n- `solve(info)`\n- `generate(info)`\n- `run(info)`\n- `CANDIDATES`, `CANDIDATE`, or `PLACEMENT`\n\nThe recommended interface is `solve(info)`. The judge calls it once per\nbenchmark. `info` contains:\n\n- `benchmark`: one of `adaptec1`, `adaptec2`, `adaptec3`, `adaptec4`,\n  `bigblue1`, `bigblue3`\n- `dim`: placement vector length\n- `node_cnt`: number of macros\n- `n_grid_x`, `n_grid_y`: MGO grid bounds\n- `max_candidates_per_submission`: 16\n- `baseline_hpwl`: the baseline HPWL used for scoring\n\nReturn either one placement vector of length `dim`, or a 2D list/array with up\nto 16 placement candidates. For MGO, the first `node_cnt` entries are x-grid\ncoordinates in `[0, n_grid_x]`, and the remaining `node_cnt` entries are y-grid\ncoordinates in `[0, n_grid_y]`.\n\nScore\n-----\n\nThe objective is to minimize MP-HPWL. For each benchmark:\n\n`raw_score = 100 * (baseline_hpwl - candidate_hpwl) / baseline_hpwl`\n\n`score = max(0, raw_score)`\n\nThe final score is the mean score over the six ISPD2005 benchmarks. The\nunbounded score is the mean raw score before the zero clip.\n\nDuring iterative agent submissions, `/app/submit.sh` gives quick feedback on\n`adaptec1` only. The final verifier evaluates the full six-benchmark suite.\nUse the quick feedback to debug general placement logic, not as the complete\nleaderboard score.\n\nThe submit helper saves the best quick-feedback artifact it has seen. During\nfinal verification, the verifier reruns both the current `/app/solution.py` and\nthat saved best iterative artifact on the full suite, then uses the better\nfull-suite score. A quick-feedback score is never used directly as the final\nreward.\n\nThe baseline constants are from the BBOPlace-Bench report, Table III,\n`MGO + Vanilla-EA` MP-HPWL. The paper reports values in units of `x10^5`; the\njudge stores raw HPWL values relaxed by `1.2x`:\n\n- `adaptec1`: `6.96e5`\n- `adaptec2`: `73.752e5`\n- `adaptec3`: `67.356e5`\n- `adaptec4`: `68.148e5`\n- `bigblue1`: `2.76e5`\n- `bigblue3`: `62.88e5`\n\nThe benchmark data and evaluator source are only present in the judge image.\nThey are not available in the agent workspace.\n", "config": "tag: optimization\nruntime:\n  language: python\n  timeout_seconds: 10800\n  environment: \"Python solution returning BBOPlace MGO placement candidates; hidden ISPD2005 judge data\"\n  apt_packages:\n    - python3-numpy\n  docker:\n    image: ubuntu:24.04\n    judge_image: ghcr.io/frontiercs/frontiercs-bboplace-data:2026-06-ispd-iccad\nenvironment:\n  cpus: 8\n  memory_mb: 16384\n  storage_mb: 8192\n  build_timeout_seconds: 3600\n"}
+{"problem_id": "bboplace_direct_iccad2015", "category": "2.0", "statement": "BBOPlace Direct ICCAD2015\n========================\n\nProblem\n-------\n\nDirectly submit one JSON macro-placement vector for one visible ICCAD2015\ndesign: `superblue1`. The hidden judge evaluates your vector with the original\nBBOPlace-Bench Mask-Guided Optimization (MGO) MP-HPWL evaluator.\n\nThis is a VLSI chip-placement optimization task. A chip design contains many\nrectangular objects. Large objects are called macros, smaller logic objects are\ncalled standard cells, and nets describe which pins on those objects must be\nconnected by wires. A placement assigns physical locations to movable objects\non a rectangular chip canvas. Good placements keep connected objects near each\nother while avoiding illegal macro overlap and boundary violations.\n\nThis direct variant gives you the raw `superblue1` ICCAD2015 input files in the\nagent workspace. You may parse those files, run local search, generate many\ntrial JSON files, and call the submit helper for feedback. Only the final\n`/app/solution.json` artifact is graded.\n\nYour JSON vector is not a final DEF placement. It is a BBOPlace MGO genotype:\none desired grid coordinate for each selected macro. The hidden evaluator\ndecodes the vector by placing macros on a 2D grid, masking out illegal grid\npositions, greedily adjusting macros to legal positions, and then reporting\nmacro-placement half-perimeter wirelength (MP-HPWL). Lower MP-HPWL is better.\n\nBackground definitions\n----------------------\n\nA net connects two or more pins. The half-perimeter wirelength of one net is:\n\n```text\n(max pin x - min pin x) + (max pin y - min pin y)\n```\n\nHPWL is the sum of that value over nets. MP-HPWL is the same idea restricted to\nthe macro-placement evaluation path used by BBOPlace-Bench. The judge reports\nonly MP-HPWL for scoring; it does not run global placement of standard cells.\n\nICCAD2015 uses an LEF/DEF-style flow. For this task the visible files have\nthese roles:\n\n```text\n.def          design components, floorplan, rows, and initial placements\n.lef          macro geometry and pin shapes\n.v            logical netlist used to select macro-to-macro nets\n.sdc          timing constraints, not used by the MP-HPWL evaluator\n*_Early.lib   early timing library, not used by the MP-HPWL evaluator\n*_Late.lib    late timing library, not used by the MP-HPWL evaluator\n```\n\nUseful ICCAD parsing notes:\n\n- `.def` component coordinates are in database units. The official MGO canvas\n  constants for this task are also provided in `/app/input_manifest.json`.\n- `.lef` contains the macro sizes and pin rectangles needed for a local\n  macro-only model.\n- `.v` contains the logical instance-to-net connections used to build\n  macro-to-macro nets for MP-HPWL.\n- `.sdc` and `.lib` files are present for completeness but are not needed by\n  the MP-HPWL scoring path.\n\nYou do not need to reproduce the official HPWL or legalizer exactly to submit a\nvalid JSON. Local parsers are useful only for choosing better coordinates before\ncalling `/app/submit.sh`.\n\nRuntime and resources\n---------------------\n\nYour final submission is a JSON file at `/app/solution.json`. You are encouraged\nto write Python programs, shell scripts, search loops, local parsers, or any\nother helper code in `/app` while working. Those programs may generate and\noverwrite `/app/solution.json` many times.\n\nThe agent container provides:\n\n- 4 CPU cores\n- 16 GiB memory\n- 8 GiB storage\n- no GPU\n- Python 3 with NumPy available for local helper scripts\n- the `superblue1` benchmark input is available in the agent workspace at\n  `/app/input/benchmarks/iccad2015/superblue1`\n\nThe judge also runs on CPU only. Do not rely on CUDA, DREAMPlace, Ray, or GPU\nplacement libraries for scoring.\n\nVisible input files\n-------------------\n\nThe agent can inspect the raw ICCAD2015 placement input while generating\n`/app/solution.json`:\n\n```text\n/app/input_manifest.json\n/app/input/benchmarks/iccad2015/superblue1/superblue1.def\n/app/input/benchmarks/iccad2015/superblue1/superblue1.iccad2015\n/app/input/benchmarks/iccad2015/superblue1/superblue1.lef\n/app/input/benchmarks/iccad2015/superblue1/superblue1.v\n/app/input/benchmarks/iccad2015/superblue1/superblue1.sdc\n/app/input/benchmarks/iccad2015/superblue1/superblue1_Early.lib\n/app/input/benchmarks/iccad2015/superblue1/superblue1_Late.lib\n```\n\nThe evaluator implementation and scoring runtime remain hidden in the judge\nimage.\n\n`/app/input_manifest.json` is the machine-readable public data channel for\ninstance-specific values and evaluator-facing conventions. Read it instead of\nhard-coding dimensions or inferring hidden details from feedback. It includes\nthe placement dimension, macro count, grid bounds, canvas information, scoring\nbaseline, macro-selection rule, selected-net rule, and a concise description of\nthe MGO decode/legalization behavior. Together with the visible LEF/DEF/Verilog\nfiles, that manifest is intended to be sufficient for building a useful local\nmodel; external repositories or internet search should not be needed.\n\nSubmission format\n-----------------\n\nSubmit exactly one placement for `superblue1` by writing `/app/solution.json`.\nAfter your program writes the file, call:\n\n```bash\nbash /app/submit.sh\n```\n\nto score that JSON through the black-box judge.\n\nThe JSON must use one of these forms:\n\n```json\n{\"placement\": [0.0, 0.0, 1.0, 1.0]}\n```\n\nor:\n\n```json\n{\"x\": [0.0, 1.0], \"y\": [0.0, 1.0]}\n```\n\nFor smoke testing, this shorthand is also accepted:\n\n```json\n{\"fill\": 0.0}\n```\n\n`{\"fill\": v}` expands inside the evaluator to a full vector where every\ncoordinate is `v`. It is a convenient way to create a syntactically valid smoke\ntest submission.\n\nThe placement vector length must equal `dim = 2 * node_cnt = 1024`. The first\n`node_cnt` entries are x-grid coordinates and the remaining `node_cnt` entries\nare y-grid coordinates:\n\n```text\nplacement[0:node_cnt]              = x-grid coordinates\nplacement[node_cnt:2 * node_cnt]   = y-grid coordinates\n```\n\nCoordinates must be finite. X coordinates must be in `[0, n_grid_x]`; y\ncoordinates must be in `[0, n_grid_y]`. Coordinates may be integers or floats.\nOnly one placement is accepted.\n\nThe public metadata needed for formatting is available before submission in\n`/app/input_manifest.json`. Judge feedback reports scores and MP-HPWL metrics;\nit should not be needed to discover vector dimensions, macro count, grid bounds,\nor MGO decode conventions. The evaluator source stays hidden in the judge\nimage.\n\nTiny example\n------------\n\nSuppose a very small toy instance had this public metadata:\n\n```text\nnode_cnt = 2\ndim = 4\nn_grid_x = 10\nn_grid_y = 8\n```\n\nThen this JSON:\n\n```json\n{\"placement\": [2.0, 7.5, 1.0, 6.0]}\n```\n\nmeans:\n\n```text\nmacro 0 desired MGO grid coordinate: (2.0, 1.0)\nmacro 1 desired MGO grid coordinate: (7.5, 6.0)\n```\n\nThe equivalent split x/y form is:\n\n```json\n{\"x\": [2.0, 7.5], \"y\": [1.0, 6.0]}\n```\n\nMinimal valid artifact\n----------------------\n\nThe repository reference solution is:\n\n```json\n{\"fill\": 0.0}\n```\n\nA small Python generator that writes a random in-bounds candidate from the\nmanifest can look like:\n\n```python\nimport json\nimport numpy as np\nfrom pathlib import Path\n\nmanifest = json.loads(Path(\"/app/input_manifest.json\").read_text())\nnode_cnt = int(manifest[\"node_cnt\"])\nn_grid_x = float(manifest[\"n_grid_x\"])\nn_grid_y = float(manifest[\"n_grid_y\"])\n\nrng = np.random.default_rng(1)\nx = rng.uniform(0.0, n_grid_x, size=node_cnt).tolist()\ny = rng.uniform(0.0, n_grid_y, size=node_cnt).tolist()\n\nwith open(\"/app/solution.json\", \"w\", encoding=\"utf-8\") as f:\n    json.dump({\"x\": x, \"y\": y}, f)\n```\n\nValidity\n--------\n\nA submission is valid if:\n\n1. `/app/solution.json` is valid JSON.\n2. It describes exactly one placement through `placement`, `x` plus `y`,\n   `candidate`, `candidates`, or `fill`.\n3. The expanded placement has exactly `1024` finite numeric values.\n4. X coordinates are in `[0, 224]` and y coordinates are in `[0, 224]`.\n5. BBOPlace can legalize the submitted candidate.\n\nInvalid submissions, out-of-bounds coordinates, malformed JSON, and candidates\nthat cannot be legalized receive score `0`.\n\nScoring\n-------\n\nThe objective is to minimize MP-HPWL for `superblue1`:\n\n```text\nraw_score = 100 * (baseline_hpwl - candidate_hpwl) / baseline_hpwl\nscore = max(0, raw_score)\n```\n\nThe baseline constant is from the BBOPlace-Bench report, Table V, `MGO + PSO`\nMP-HPWL. The report uses units of `x10^5`; the judge stores the raw HPWL value\nrelaxed by `1.2x`:\n\n```text\nsuperblue1  0.696e5\n```\n\nBoth iterative submissions and final verification evaluate this same single\ndesign. The submit helper may still save the best iterative JSON artifact and\nrerun it during final verification.\n", "config": "tag: optimization\nruntime:\n  language: json\n  timeout_seconds: 10800\n  environment: \"JSON placement for one visible ICCAD2015 BBOPlace design; hidden evaluator\"\n  apt_packages:\n    - python3-numpy\n  docker:\n    image: ubuntu:24.04\n    judge_image: ghcr.io/frontiercs/frontiercs-bboplace-data:2026-06-ispd-iccad\n  visible_inputs:\n    - source: /opt/bboplace-bench/benchmarks/iccad2015/superblue1\n      destination: /app/input/benchmarks/iccad2015/superblue1\nsubmission:\n  kind: file\n  path: /app/solution.json\nenvironment:\n  cpus: 4\n  memory_mb: 16384\n  storage_mb: 8192\n  build_timeout_seconds: 3600\n"}
+{"problem_id": "bboplace_direct_ispd2005", "category": "2.0", "statement": "BBOPlace Direct ISPD2005\n=======================\n\nProblem\n-------\n\nDirectly submit one JSON macro-placement vector for one visible ISPD2005\ndesign: `adaptec1`. The hidden judge evaluates your vector with the original\nBBOPlace-Bench Mask-Guided Optimization (MGO) MP-HPWL evaluator.\n\nThis is a VLSI chip-placement optimization task. A chip design contains many\nrectangular objects. Large objects are called macros, smaller logic objects are\ncalled standard cells, and nets describe which pins on those objects must be\nconnected by wires. A placement assigns physical locations to movable objects\non a rectangular chip canvas. Good placements keep connected objects near each\nother while avoiding illegal macro overlap and boundary violations.\n\nThis direct variant gives you the raw `adaptec1` Bookshelf benchmark files in\nthe agent workspace. You may parse those files, run local search, generate many\ntrial JSON files, and call the submit helper for feedback. Only the final\n`/app/solution.json` artifact is graded.\n\nYour JSON vector is not a final Bookshelf `.pl` solution. It is a BBOPlace MGO\ngenotype: one desired grid coordinate for each macro. The hidden evaluator\ndecodes the vector by placing macros on a 2D grid, masking out illegal grid\npositions, greedily adjusting macros to legal positions, and then reporting\nmacro-placement half-perimeter wirelength (MP-HPWL). Lower MP-HPWL is better.\n\nBackground definitions\n----------------------\n\nA net connects two or more pins. The half-perimeter wirelength of one net is:\n\n```text\n(max pin x - min pin x) + (max pin y - min pin y)\n```\n\nHPWL is the sum of that value over nets. MP-HPWL is the same idea restricted to\nthe macro-placement evaluation path used by BBOPlace-Bench. The judge reports\nonly MP-HPWL for scoring; it does not run global placement of standard cells.\n\nISPD2005 uses the Bookshelf placement format. For this task the visible files\nhave these roles:\n\n```text\n.aux    lists the component files for this benchmark instance\n.nodes  object names, sizes, and terminal/fixed status\n.nets   net connectivity and optional pin offsets\n.pl     initial or solution locations and orientations\n.scl    row/floorplan information\n.wts    optional net or object weights\n```\n\nUseful parsing notes:\n\n- Lines beginning with `#` are comments in typical Bookshelf files.\n- `.nodes` contains `NumNodes`, `NumTerminals`, then rows like\n  `name width height` with optional `terminal`.\n- `.nets` contains `NumNets`, `NumPins`, then `NetDegree : k net_name`\n  followed by `k` pin rows. Pin rows name an object and may include x/y pin\n  offsets after `:`.\n- `.pl` contains object locations. Fixed terminals are usually marked with\n  `/FIXED` or `/FIXED_NI`.\n- `.scl` describes placement rows and can be used to infer the legal canvas\n  region. The official MGO grid bounds for this task are also provided in\n  `/app/input_manifest.json`.\n\nYou do not need to reproduce the official HPWL or legalizer exactly to submit a\nvalid JSON. Local parsers are useful only for choosing better coordinates before\ncalling `/app/submit.sh`.\n\nRuntime and resources\n---------------------\n\nYour final submission is a JSON file at `/app/solution.json`. You are encouraged\nto write Python programs, shell scripts, search loops, local parsers, or any\nother helper code in `/app` while working. Those programs may generate and\noverwrite `/app/solution.json` many times.\n\nThe agent container provides:\n\n- 4 CPU cores\n- 16 GiB memory\n- 8 GiB storage\n- no GPU\n- Python 3 with NumPy available for local helper scripts\n- the `adaptec1` benchmark input is available in the agent workspace at\n  `/app/input/benchmarks/ispd2005/adaptec1`\n\nThe judge also runs on CPU only. Do not rely on CUDA, DREAMPlace, Ray, or GPU\nplacement libraries for scoring.\n\nVisible input files\n-------------------\n\nThe agent can inspect the raw ISPD2005 placement input while generating\n`/app/solution.json`:\n\n```text\n/app/input_manifest.json\n/app/input/benchmarks/ispd2005/adaptec1/adaptec1.aux\n/app/input/benchmarks/ispd2005/adaptec1/adaptec1.dp.aux\n/app/input/benchmarks/ispd2005/adaptec1/adaptec1.eplace-ip.pl\n/app/input/benchmarks/ispd2005/adaptec1/adaptec1.eplace.aux\n/app/input/benchmarks/ispd2005/adaptec1/adaptec1.lg.pl\n/app/input/benchmarks/ispd2005/adaptec1/adaptec1.nodes\n/app/input/benchmarks/ispd2005/adaptec1/adaptec1.nets\n/app/input/benchmarks/ispd2005/adaptec1/adaptec1.pl\n/app/input/benchmarks/ispd2005/adaptec1/adaptec1.scl\n/app/input/benchmarks/ispd2005/adaptec1/adaptec1.wts\n```\n\nThe evaluator implementation and scoring runtime remain hidden in the judge\nimage.\n\n`/app/input_manifest.json` is the machine-readable public data channel for\ninstance-specific values and evaluator-facing conventions. Read it instead of\nhard-coding dimensions or inferring hidden details from feedback. It includes\nthe placement dimension, macro count, grid bounds, canvas information, scoring\nbaseline, macro-selection rule, selected-net rule, and a concise description of\nthe MGO decode/legalization behavior. Together with the visible Bookshelf files,\nthat manifest is intended to be sufficient for building a useful local model;\nexternal repositories or internet search should not be needed.\n\nSubmission format\n-----------------\n\nSubmit exactly one placement for `adaptec1` by writing `/app/solution.json`.\nAfter your program writes the file, call:\n\n```bash\nbash /app/submit.sh\n```\n\nto score that JSON through the black-box judge.\n\nThe JSON must use one of these forms:\n\n```json\n{\"placement\": [0.0, 0.0, 1.0, 1.0]}\n```\n\nor:\n\n```json\n{\"x\": [0.0, 1.0], \"y\": [0.0, 1.0]}\n```\n\nFor smoke testing, this shorthand is also accepted:\n\n```json\n{\"fill\": 0.0}\n```\n\n`{\"fill\": v}` expands inside the evaluator to a full vector where every\ncoordinate is `v`. It is a convenient way to create a syntactically valid smoke\ntest submission.\n\nThe placement vector length must equal `dim = 2 * node_cnt`. The first\n`node_cnt` entries are x-grid coordinates and the remaining `node_cnt` entries\nare y-grid coordinates:\n\n```text\nplacement[0:node_cnt]              = x-grid coordinates\nplacement[node_cnt:2 * node_cnt]   = y-grid coordinates\n```\n\nCoordinates must be finite. X coordinates must be in `[0, n_grid_x]`; y\ncoordinates must be in `[0, n_grid_y]`. Coordinates may be integers or floats.\nOnly one placement is accepted.\n\nThe public metadata needed for formatting is available before submission in\n`/app/input_manifest.json`. Judge feedback reports scores and MP-HPWL metrics;\nit should not be needed to discover vector dimensions or grid bounds. The\nevaluator source stays hidden in the judge image.\n\nTiny example\n------------\n\nSuppose a very small toy instance had this public metadata:\n\n```text\nnode_cnt = 2\ndim = 4\nn_grid_x = 10\nn_grid_y = 8\n```\n\nThen this JSON:\n\n```json\n{\"placement\": [2.0, 7.5, 1.0, 6.0]}\n```\n\nmeans:\n\n```text\nmacro 0 desired MGO grid coordinate: (2.0, 1.0)\nmacro 1 desired MGO grid coordinate: (7.5, 6.0)\n```\n\nThe equivalent split x/y form is:\n\n```json\n{\"x\": [2.0, 7.5], \"y\": [1.0, 6.0]}\n```\n\nMinimal valid artifact\n----------------------\n\nThe repository reference solution is:\n\n```json\n{\"fill\": 0.0}\n```\n\nA small Python generator that writes a random in-bounds candidate from the\nmanifest can look like:\n\n```python\nimport json\nimport numpy as np\nfrom pathlib import Path\n\nmanifest = json.loads(Path(\"/app/input_manifest.json\").read_text())\nnode_cnt = int(manifest[\"node_cnt\"])\nn_grid_x = float(manifest[\"n_grid_x\"])\nn_grid_y = float(manifest[\"n_grid_y\"])\n\nrng = np.random.default_rng(1)\nx = rng.uniform(0.0, n_grid_x, size=node_cnt).tolist()\ny = rng.uniform(0.0, n_grid_y, size=node_cnt).tolist()\n\nwith open(\"/app/solution.json\", \"w\", encoding=\"utf-8\") as f:\n    json.dump({\"x\": x, \"y\": y}, f)\n```\n\nValidity\n--------\n\nA submission is valid if:\n\n1. `/app/solution.json` is valid JSON.\n2. It describes exactly one placement through `placement`, `x` plus `y`, or\n   `fill`.\n3. The expanded placement has exactly `dim` finite numeric values.\n4. X coordinates are in `[0, n_grid_x]` and y coordinates are in\n   `[0, n_grid_y]`.\n5. BBOPlace can legalize the submitted candidate.\n\nInvalid submissions, out-of-bounds coordinates, malformed JSON, and candidates\nthat cannot be legalized receive score `0`.\n\nScoring\n-------\n\nThe objective is to minimize MP-HPWL for `adaptec1`:\n\n```text\nraw_score = 100 * (baseline_hpwl - candidate_hpwl) / baseline_hpwl\nscore = max(0, raw_score)\n```\n\nThe baseline constant is from the BBOPlace-Bench report, Table III,\n`MGO + Vanilla-EA` MP-HPWL. The report uses units of `x10^5`; the judge stores\nthe raw HPWL value relaxed by `1.2x`:\n\n```text\nadaptec1  6.96e5\n```\n\nBoth iterative submissions and final verification evaluate this same single\ndesign. The submit helper may still save the best iterative JSON artifact and\nrerun it during final verification.\n", "config": "tag: optimization\nruntime:\n  language: json\n  timeout_seconds: 10800\n  environment: \"JSON placement for one visible ISPD2005 BBOPlace design; hidden evaluator\"\n  apt_packages:\n    - python3-numpy\n  docker:\n    image: ubuntu:24.04\n    judge_image: ghcr.io/frontiercs/frontiercs-bboplace-data:2026-06-ispd-iccad\n  visible_inputs:\n    - source: /opt/bboplace-bench/benchmarks/ispd2005/adaptec1\n      destination: /app/input/benchmarks/ispd2005/adaptec1\nsubmission:\n  kind: file\n  path: /app/solution.json\nenvironment:\n  cpus: 4\n  memory_mb: 16384\n  storage_mb: 8192\n  build_timeout_seconds: 3600\n"}
+{"problem_id": "bboplace_iccad2015", "category": "2.0", "statement": "BBOPlace ICCAD2015\n==================\n\nProblem\n-------\n\nWrite a Python solution that proposes macro placements for the BBOPlace\nMask-Guided Optimization (MGO) formulation on eight ICCAD2015 placement\nbenchmarks:\n\n```text\nsuperblue1, superblue3, superblue4, superblue5,\nsuperblue7, superblue10, superblue16, superblue18\n```\n\nThis is a VLSI chip-placement optimization task. A chip design contains many\nrectangular objects. Large objects are called macros, smaller logic objects are\ncalled standard cells, and nets describe which pins on those objects must be\nconnected by wires. A placement assigns physical locations to the movable\nobjects on a rectangular chip canvas. Good placements keep connected objects\nnear each other while avoiding illegal macro overlap and boundary violations.\n\nThis task uses the BBOPlace-Bench MGO representation. Your submitted vector is\nnot a final physical DEF placement. It is a genotype: one desired grid\ncoordinate for each macro. The hidden BBOPlace evaluator decodes that genotype\nby placing macros on a 2D grid, masking out illegal grid positions, greedily\nadjusting macros to legal positions, and then reporting macro-placement\nhalf-perimeter wirelength (MP-HPWL). Lower MP-HPWL is better.\n\nYou do not need to implement an ICCAD2015 parser, a legalizer, HPWL\ncomputation, or BBOPlace itself for this suite task. The judge owns the hidden\nbenchmark files and the original BBOPlace-Bench evaluator. Your job is to\ngenerate promising candidate coordinate vectors from the public metadata passed\nto `solve(info)`. External repositories, papers, internet search, and BBOPlace\nsource code are not needed for this task. Do not try to fetch or reconstruct\nthe hidden evaluator. Treat it as a black box and use only the task statement,\n`AGENT.md`, the `info` dictionary passed to your solution, and feedback\nreturned by `/app/submit.sh`.\n\nBackground definitions\n----------------------\n\nA net connects two or more pins. The half-perimeter wirelength of one net is:\n\n```text\n(max pin x - min pin x) + (max pin y - min pin y)\n```\n\nHPWL is the sum of that value over nets. MP-HPWL is the same idea restricted to\nthe macro-placement evaluation path used by BBOPlace-Bench. The judge reports\nonly MP-HPWL for scoring; it does not run global placement of standard cells.\n\nICCAD2015 contest designs are distributed in an LEF/DEF-style flow. The\nimportant file roles are:\n\n```text\n.def          design components, pins, nets, floorplan, and placement data\n.lef          technology and macro geometry\n.v            logical netlist\n.sdc          timing constraints\n*_Early.lib   early timing library\n*_Late.lib    late timing library\n```\n\nThose files are hidden for this suite task. They are described here only so the\noptimization problem is clear.\n\nRuntime and resources\n---------------------\n\nYour solution runs in the main agent container with:\n\n- 4 CPU cores\n- 16 GiB memory\n- 8 GiB storage\n- no GPU\n- Python 3 with NumPy available\n\nThe final verifier timeout is 10800 seconds. The judge also runs on CPU only.\nDo not rely on CUDA, DREAMPlace, Ray, or GPU placement libraries for scoring;\nthe official metric path used here is MGO with MP-HPWL.\n\nSubmission interface\n--------------------\n\nCreate `/app/solution.py`. It must define one of:\n\n- `solve(info)`\n- `generate(info)`\n- `run(info)`\n- `CANDIDATES`, `CANDIDATE`, or `PLACEMENT`\n\nThe recommended interface is `solve(info)`. The judge imports the file in an\nisolated process and calls it once per selected benchmark. `info` is a\nJSON-like dictionary containing:\n\n```text\ndataset: \"iccad2015\"\nbenchmark: one of superblue1, superblue3, superblue4, superblue5,\n           superblue7, superblue10, superblue16, superblue18\nplacer: \"mgo\"\nmetric: \"mp_hpwl\"\nobjective: \"minimize\"\ndim: placement vector length, always 2 * node_cnt\nnode_cnt: number of movable macros represented by the vector\nnet_cnt: number of nets in the benchmark\ncanvas_width, canvas_height: physical canvas dimensions\nn_grid_x, n_grid_y: inclusive MGO grid-coordinate upper bounds\nbounds_kind: \"mgo_repeated_grid\"\nmax_candidates_per_submission: 16\nbaseline_hpwl: the HPWL baseline used for scoring\n```\n\nThe `info` dictionary is the public data channel for benchmark-specific\nconstants in this suite task. The raw ICCAD2015 files stay hidden, but the\nconstants needed to create a syntactically valid placement are provided on\nevery call to `solve(info)`. In particular, do not assume that the\nquick-feedback benchmark dimensions also apply to the full suite. Read `dim`,\n`node_cnt`, `n_grid_x`, `n_grid_y`, `canvas_width`, `canvas_height`, and\n`baseline_hpwl` from the `info` argument each time the function is called.\n\nBecause the raw netlist and macro order are hidden, a useful solver should\nreturn several robust coordinate patterns rather than trying to compute true\nHPWL locally. Examples include zero or center fills, edge/corner spreads,\ndiagonal or striped layouts, clustered layouts, deterministic random layouts,\nand small deterministic variants keyed by `info[\"benchmark\"]`. The judge will\nevaluate up to 16 candidates and keep the best legal candidate for each\nbenchmark.\n\nThe final verifier calls your solution separately for:\n\n```text\nsuperblue1, superblue3, superblue4, superblue5,\nsuperblue7, superblue10, superblue16, superblue18\n```\n\nEach call has the same field names but may have different values. A correct\nsolution can therefore be written without knowing or hard-coding the per-design\nconstants in advance:\n\n```python\ndef solve(info):\n    n = int(info[\"node_cnt\"])\n    gx = float(info[\"n_grid_x\"])\n    gy = float(info[\"n_grid_y\"])\n    x = [0.5 * gx] * n\n    y = [0.5 * gy] * n\n    return x + y\n```\n\nReturn either one placement vector of length `dim`, or a 2D list/NumPy array\nwith up to 16 placement candidates. For every candidate:\n\n```text\ncandidate[0:node_cnt]              = x-grid coordinates\ncandidate[node_cnt:2 * node_cnt]   = y-grid coordinates\nx coordinates must be finite and in [0, n_grid_x]\ny coordinates must be finite and in [0, n_grid_y]\n```\n\nCoordinates may be integers or floats. They are interpreted by BBOPlace's MGO\ndecoder as desired grid positions; the decoder may move macros during legality\nrepair. If you return multiple candidates, the judge evaluates all of them and\nuses the candidate with the lowest legal MP-HPWL for that benchmark.\n\nA minimal valid solution is:\n\n```python\ndef solve(info):\n    return [0.0] * int(info[\"dim\"])\n```\n\nTiny example\n------------\n\nSuppose the judge called `solve(info)` with this small illustrative metadata:\n\n```python\ninfo = {\n    \"benchmark\": \"toy\",\n    \"node_cnt\": 2,\n    \"dim\": 4,\n    \"n_grid_x\": 10,\n    \"n_grid_y\": 8,\n}\n```\n\nThen a valid single candidate could be:\n\n```python\n[2.0, 7.5, 1.0, 6.0]\n```\n\nThe first `node_cnt = 2` values are x-grid coordinates, and the last two values\nare y-grid coordinates. This candidate asks MGO to place macro 0 near grid\n`(2.0, 1.0)` and macro 1 near grid `(7.5, 6.0)`. A two-candidate return value\nfor the same toy metadata could be:\n\n```python\n[\n    [2.0, 7.5, 1.0, 6.0],\n    [0.0, 10.0, 0.0, 8.0],\n]\n```\n\nA simple multi-candidate skeleton is:\n\n```python\nimport numpy as np\n\n\ndef solve(info):\n    n = int(info[\"node_cnt\"])\n    dim = int(info[\"dim\"])\n    gx = float(info[\"n_grid_x\"])\n    gy = float(info[\"n_grid_y\"])\n    name = str(info[\"benchmark\"])\n    seed = sum((i + 1) * ord(ch) for i, ch in enumerate(name)) % (2**32)\n    rng = np.random.default_rng(seed)\n\n    candidates = []\n    candidates.append(np.zeros(dim))\n    for _ in range(15):\n        x = rng.uniform(0.0, gx, size=n)\n        y = rng.uniform(0.0, gy, size=n)\n        candidates.append(np.concatenate([x, y]))\n    return np.asarray(candidates)\n```\n\nLocal harness\n-------------\n\nThe official evaluator uses hidden data and a black-box judge. During a Harbor\ntrial you may call:\n\n```bash\nbash /app/submit.sh\n```\n\nto submit the current `/app/solution.py` and receive public score feedback.\n\nDuring iterative agent submissions, `/app/submit.sh` gives quick feedback on\n`superblue1` only. The final verifier evaluates the full eight-benchmark\nsuite. Use the quick feedback to debug general placement logic, candidate\nformatting, and search ideas, not as the complete leaderboard score.\n\nThe submit helper saves the best quick-feedback artifact it has seen. During\nfinal verification, the verifier reruns both the current `/app/solution.py` and\nthat saved best iterative artifact on the full suite, then uses the better\nfull-suite score. A quick-feedback score is never used directly as the final\nreward.\n\nValidity\n--------\n\nA submission is valid if:\n\n1. `/app/solution.py` imports successfully with Python 3.\n2. It exposes one of the accepted interfaces listed above.\n3. For each benchmark call, it returns one to 16 candidates.\n4. Every candidate has exactly `dim` finite numeric values.\n5. X coordinates are in `[0, n_grid_x]` and y coordinates are in\n   `[0, n_grid_y]`.\n6. BBOPlace can legalize at least one candidate for each evaluated benchmark.\n\nInvalid submissions, timeouts, and candidates that cannot be legalized receive\nscore `0`.\n\nScoring\n-------\n\nThe objective is to minimize MP-HPWL. For each benchmark:\n\n```text\nraw_score = 100 * (baseline_hpwl - candidate_hpwl) / baseline_hpwl\nscore = max(0, raw_score)\n```\n\nThe final score is the mean score over the eight ICCAD2015 benchmarks. The\nunbounded score is the mean raw score before the zero clip.\n\nThe baseline constants are from the BBOPlace-Bench report, Table V,\n`MGO + PSO` MP-HPWL. The paper reports values in units of `x10^5`; the judge\nstores raw HPWL values relaxed by `1.2x`:\n\n```text\nsuperblue1:  0.696e5\nsuperblue3:  1.824e5\nsuperblue4:  1.128e5\nsuperblue5:  4.512e5\nsuperblue7:  2.028e5\nsuperblue10: 0.648e5\nsuperblue16: 1.152e5\nsuperblue18: 0.576e5\n```\n", "config": "tag: optimization\nruntime:\n  language: python\n  timeout_seconds: 10800\n  environment: \"Python solution returning BBOPlace MGO placement candidates; hidden ICCAD2015 judge data\"\n  apt_packages:\n    - python3-numpy\n  docker:\n    image: ubuntu:24.04\n    judge_image: ghcr.io/frontiercs/frontiercs-bboplace-data:2026-06-ispd-iccad\nenvironment:\n  cpus: 4\n  memory_mb: 16384\n  storage_mb: 8192\n  build_timeout_seconds: 3600\n"}
+{"problem_id": "bboplace_ispd2005", "category": "2.0", "statement": "BBOPlace ISPD2005\n=================\n\nProblem\n-------\n\nWrite a Python solution that proposes macro placements for the BBOPlace\nMask-Guided Optimization (MGO) formulation on six ISPD2005 placement\nbenchmarks:\n\n```text\nadaptec1, adaptec2, adaptec3, adaptec4, bigblue1, bigblue3\n```\n\nThis is a VLSI chip-placement optimization task. A chip design contains many\nrectangular objects. Large objects are called macros, smaller logic objects are\ncalled standard cells, and nets describe which pins on those objects must be\nconnected by wires. A placement assigns physical locations to the movable\nobjects on a rectangular chip canvas. Good placements keep connected objects\nnear each other while avoiding illegal macro overlap and boundary violations.\n\nThis task uses the BBOPlace-Bench MGO representation. Your submitted vector is\nnot a final physical `.pl` file. It is a genotype: one desired grid coordinate\nfor each macro. The hidden BBOPlace evaluator decodes that genotype by placing\nmacros on a 2D grid, masking out illegal grid positions, greedily adjusting\nmacros to legal positions, and then reporting macro-placement half-perimeter\nwirelength (MP-HPWL). Lower MP-HPWL is better.\n\nYou do not need to implement an ISPD parser, a legalizer, HPWL computation, or\nBBOPlace itself for this suite task. The judge owns the hidden benchmark files\nand the original BBOPlace-Bench evaluator. Your job is to generate promising\ncandidate coordinate vectors from the public metadata passed to `solve(info)`.\nExternal repositories, papers, internet search, and BBOPlace source code are\nnot needed for this task. Do not try to fetch or reconstruct the hidden\nevaluator. Treat it as a black box and use only the task statement, `AGENT.md`,\nthe `info` dictionary passed to your solution, and feedback returned by\n`/app/submit.sh`.\n\nBackground definitions\n----------------------\n\nA net connects two or more pins. The half-perimeter wirelength of one net is:\n\n```text\n(max pin x - min pin x) + (max pin y - min pin y)\n```\n\nHPWL is the sum of that value over nets. MP-HPWL is the same idea restricted to\nthe macro-placement evaluation path used by BBOPlace-Bench. The judge reports\nonly MP-HPWL for scoring; it does not run global placement of standard cells.\n\nISPD2005 designs are stored in the Bookshelf placement format. The important\nfile roles are:\n\n```text\n.aux    lists the component files for one benchmark instance\n.nodes  object names, sizes, and terminal/fixed status\n.nets   net connectivity and optional pin offsets\n.pl     initial or solution locations and orientations\n.scl    row/floorplan information\n.wts    optional net or object weights\n```\n\nThose files are hidden for this suite task. They are described here only so the\noptimization problem is clear.\n\nRuntime and resources\n---------------------\n\nYour solution runs in the main agent container with:\n\n- 4 CPU cores\n- 16 GiB memory\n- 8 GiB storage\n- no GPU\n- Python 3 with NumPy available\n\nThe final verifier timeout is 10800 seconds. The judge also runs on CPU only.\nDo not rely on CUDA, DREAMPlace, Ray, or GPU placement libraries for scoring;\nthe official metric path used here is MGO with MP-HPWL.\n\nSubmission interface\n--------------------\n\nCreate `/app/solution.py`. It must define one of:\n\n- `solve(info)`\n- `generate(info)`\n- `run(info)`\n- `CANDIDATES`, `CANDIDATE`, or `PLACEMENT`\n\nThe recommended interface is `solve(info)`. The judge imports the file in an\nisolated process and calls it once per selected benchmark. `info` is a JSON-like\ndictionary containing:\n\n```text\ndataset: \"ispd2005\"\nbenchmark: one of adaptec1, adaptec2, adaptec3, adaptec4, bigblue1, bigblue3\nplacer: \"mgo\"\nmetric: \"mp_hpwl\"\nobjective: \"minimize\"\ndim: placement vector length, always 2 * node_cnt\nnode_cnt: number of movable macros represented by the vector\nnet_cnt: number of nets in the benchmark\ncanvas_width, canvas_height: physical canvas dimensions\nn_grid_x, n_grid_y: inclusive MGO grid-coordinate upper bounds\nbounds_kind: \"mgo_repeated_grid\"\nmax_candidates_per_submission: 16\nbaseline_hpwl: the HPWL baseline used for scoring\n```\n\nThe `info` dictionary is the public data channel for benchmark-specific\nconstants in this suite task. The raw ISPD2005 Bookshelf files stay hidden, but\nthe constants needed to create a syntactically valid placement are provided on\nevery call to `solve(info)`. In particular, do not assume that the quick-feedback\nbenchmark dimensions also apply to the full suite. Read `dim`, `node_cnt`,\n`n_grid_x`, `n_grid_y`, `canvas_width`, `canvas_height`, and `baseline_hpwl`\nfrom the `info` argument each time the function is called.\n\nBecause the raw netlist and macro order are hidden, a useful solver should\nreturn several robust coordinate patterns rather than trying to compute true\nHPWL locally. Examples include zero or center fills, edge/corner spreads,\ndiagonal or striped layouts, clustered layouts, deterministic random layouts,\nand small deterministic variants keyed by `info[\"benchmark\"]`. The judge will\nevaluate up to 16 candidates and keep the best legal candidate for each\nbenchmark.\n\nThe final verifier calls your solution separately for:\n\n```text\nadaptec1, adaptec2, adaptec3, adaptec4, bigblue1, bigblue3\n```\n\nEach call has the same field names but may have different values. A correct\nsolution can therefore be written without knowing or hard-coding the per-design\nconstants in advance:\n\n```python\ndef solve(info):\n    n = int(info[\"node_cnt\"])\n    gx = float(info[\"n_grid_x\"])\n    gy = float(info[\"n_grid_y\"])\n    x = [0.5 * gx] * n\n    y = [0.5 * gy] * n\n    return x + y\n```\n\nReturn either one placement vector of length `dim`, or a 2D list/NumPy array\nwith up to 16 placement candidates. For every candidate:\n\n```text\ncandidate[0:node_cnt]              = x-grid coordinates\ncandidate[node_cnt:2 * node_cnt]   = y-grid coordinates\nx coordinates must be finite and in [0, n_grid_x]\ny coordinates must be finite and in [0, n_grid_y]\n```\n\nCoordinates may be integers or floats. They are interpreted by BBOPlace's MGO\ndecoder as desired grid positions; the decoder may move macros during legality\nrepair. If you return multiple candidates, the judge evaluates all of them and\nuses the candidate with the lowest legal MP-HPWL for that benchmark.\n\nA minimal valid solution is:\n\n```python\ndef solve(info):\n    return [0.0] * int(info[\"dim\"])\n```\n\nTiny example\n------------\n\nSuppose the judge called `solve(info)` with this small illustrative metadata:\n\n```python\ninfo = {\n    \"benchmark\": \"toy\",\n    \"node_cnt\": 2,\n    \"dim\": 4,\n    \"n_grid_x\": 10,\n    \"n_grid_y\": 8,\n}\n```\n\nThen a valid single candidate could be:\n\n```python\n[2.0, 7.5, 1.0, 6.0]\n```\n\nThe first `node_cnt = 2` values are x-grid coordinates, and the last two values\nare y-grid coordinates. This candidate asks MGO to place macro 0 near grid\n`(2.0, 1.0)` and macro 1 near grid `(7.5, 6.0)`. A two-candidate return value\nfor the same toy metadata could be:\n\n```python\n[\n    [2.0, 7.5, 1.0, 6.0],\n    [0.0, 10.0, 0.0, 8.0],\n]\n```\n\nA simple multi-candidate skeleton is:\n\n```python\nimport numpy as np\n\n\ndef solve(info):\n    n = int(info[\"node_cnt\"])\n    dim = int(info[\"dim\"])\n    gx = float(info[\"n_grid_x\"])\n    gy = float(info[\"n_grid_y\"])\n    rng = np.random.default_rng(abs(hash(info[\"benchmark\"])) % (2**32))\n\n    candidates = []\n    candidates.append(np.zeros(dim))\n    for _ in range(15):\n        x = rng.uniform(0.0, gx, size=n)\n        y = rng.uniform(0.0, gy, size=n)\n        candidates.append(np.concatenate([x, y]))\n    return np.asarray(candidates)\n```\n\nLocal harness\n-------------\n\nThe official evaluator uses hidden data and a black-box judge. During a Harbor\ntrial you may call:\n\n```bash\nbash /app/submit.sh\n```\n\nto submit the current `/app/solution.py` and receive public score feedback.\n\nDuring iterative agent submissions, `/app/submit.sh` gives quick feedback on\n`adaptec1` only. The final verifier evaluates the full six-benchmark suite.\nUse the quick feedback to debug general placement logic, candidate formatting,\nand search ideas, not as the complete leaderboard score.\n\nThe submit helper saves the best quick-feedback artifact it has seen. During\nfinal verification, the verifier reruns both the current `/app/solution.py` and\nthat saved best iterative artifact on the full suite, then uses the better\nfull-suite score. A quick-feedback score is never used directly as the final\nreward.\n\nValidity\n--------\n\nA submission is valid if:\n\n1. `/app/solution.py` imports successfully with Python 3.\n2. It exposes one of the accepted interfaces listed above.\n3. For each benchmark call, it returns one to 16 candidates.\n4. Every candidate has exactly `dim` finite numeric values.\n5. X coordinates are in `[0, n_grid_x]` and y coordinates are in\n   `[0, n_grid_y]`.\n6. BBOPlace can legalize at least one candidate for each evaluated benchmark.\n\nInvalid submissions, timeouts, and candidates that cannot be legalized receive\nscore `0`.\n\nScoring\n-------\n\nThe objective is to minimize MP-HPWL. For each benchmark:\n\n```text\nraw_score = 100 * (baseline_hpwl - candidate_hpwl) / baseline_hpwl\nscore = max(0, raw_score)\n```\n\nThe final score is the mean score over the six ISPD2005 benchmarks. The\nunbounded score is the mean raw score before the zero clip.\n", "config": "tag: optimization\nruntime:\n  language: python\n  timeout_seconds: 10800\n  environment: \"Python solution returning BBOPlace MGO placement candidates; hidden ISPD2005 judge data\"\n  apt_packages:\n    - python3-numpy\n    - python3-matplotlib\n    - python3-pil\n  docker:\n    image: ubuntu:24.04\n    judge_image: ghcr.io/frontiercs/frontiercs-bboplace-data:2026-06-ispd-iccad\nenvironment:\n  cpus: 4\n  memory_mb: 16384\n  storage_mb: 8192\n  build_timeout_seconds: 3600\n"}
 {"problem_id": "duckdb_e2e_query_optimization", "category": "2.0", "statement": "# DuckDB E2E Query Optimization\n\n## Problem\n\nThis is an experimental systems task. You are given a pinned DuckDB checkout in\nthe Harbor workspace and may modify DuckDB itself. Your goal is to improve\nend-to-end TPC-H style analytical query performance while preserving the\ncorrectness and generality of DuckDB's SQL execution.\n\nThe intended optimization area is end-to-end analytical query optimization:\njoin ordering, predicate transfer, join-side filtering, cardinality robustness,\nand closely related optimizer/execution wiring. Strong submissions should\nimprove TPC-H geometric mean runtime without hard-coding TPC-H tables, queries,\nbenchmark paths, or judge details.\n\n## Workload\n\nThe public workload family is DuckDB's built-in TPC-H query set. The public\nscale factor is 1, and the experimental judge evaluates q1 through q22 with\nDuckDB's TPC-H extension, for example by generating data with `CALL dbgen(...)`\nand running queries through `PRAGMA tpch(n)`. DuckDB also exposes its TPC-H\nquery text through the extension in normal DuckDB development workflows.\n\nTreat those queries as a representative analytical workload, not as strings to\nrecognize. The judge may include additional non-public scale-factor groups, and\nit may vary query order, repetitions, and correctness coverage. Submissions\nshould implement general optimizer and execution improvements rather than\nTPC-H-specific special cases.\n\n## Submission\n\nThe submitted artifact is a patch file:\n\n```text\n/app/solution.patch\n```\n\nThe agent workspace is expected to contain a DuckDB checkout at:\n\n```text\n/app/duckdb\n```\n\nAfter modifying DuckDB, generate and submit a patch:\n\n```bash\nbash /app/make_submission.sh\nbash /app/submit.sh\n```\n\nSubmissions are asynchronous. For this task, submit an initial small, plausible\npatch as soon as it is generated, then continue local review or compilation\nwhile the judge works. A full local DuckDB build in the agent container can\nconsume most of the agent budget and is not required before the first\nsubmission; the judge builds the submitted patch from a clean prebuilt source\ntree with fixed resource settings.\n\nThe judge applies the patch to a clean pinned DuckDB source tree, builds DuckDB\nwith the TPC-H extension enabled, and times the evaluated TPC-H queries from\nthe judge side. Submitted binaries, build artifacts, generated benchmark files,\nand local timing logs are ignored.\n\n## Correctness\n\nCorrectness is a gate. Patched DuckDB must produce the same SQL results as\nvanilla DuckDB on the evaluated workload. Build failures, patch failures,\nincorrect query results, crashes, timeouts, and out-of-memory failures are\npenalized before performance is considered.\n\nThe experimental evaluator currently encodes the patch policy, timing\norchestration, and vanilla-vs-patched TPC-H result comparison inside the custom\njudge image. During iterative asynchronous submissions, the judge keeps feedback\nfocused on the public scale-factor TPC-H gate so agents can submit early and\ncontinue working while evaluation runs. During final verification, the judge\nuses the broader hidden scale-factor set and also runs a small DuckDB\nSQLLogicTest smoke set covering join, filter, and aggregate behavior before\ntiming is considered.\n\n## Scoring\n\nValid submissions are scored by speedup relative to vanilla DuckDB on the same\nhardware, same benchmark list, same clean environment, and same resource limits.\nFor each benchmark query:\n\n```text\nspeedup = vanilla_time / patched_time\n```\n\nThe primary objective is the geometric mean of per-query speedups. The bounded\nscore is derived from that geometric mean so that a 1.0x result earns 0 points,\nregressions also earn 0 points, and broad speedups are preferred over a single\nlarge outlier. The raw geometric mean speedup is reported in evaluator metrics.\n\n## Patch Policy\n\nThe evaluator validates the patch before building. The policy is intentionally\nstricter than normal DuckDB development because this task is graded by hidden\nbenchmarks.\n\nAllowed optimizer and execution areas:\n\n```text\nsrc/optimizer/**\nsrc/include/duckdb/optimizer/**\nsrc/execution/operator/join/**\nsrc/include/duckdb/execution/operator/join/**\nsrc/execution/operator/filter/**\nsrc/include/duckdb/execution/operator/filter/**\nsrc/planner/operator/logical_join.cpp\nsrc/planner/operator/logical_comparison_join.cpp\nsrc/include/duckdb/planner/operator/logical_join.hpp\nsrc/include/duckdb/planner/operator/logical_comparison_join.hpp\n```\n\nConditionally allowed narrow wiring areas:\n\n```text\nsrc/planner/**\nsrc/include/duckdb/planner/**\nsrc/execution/physical_plan/**\nsrc/include/duckdb/execution/physical_plan/**\nsrc/common/**\nsrc/include/duckdb/common/**\n```\n\nNew C++ and header files are allowed in these areas. Build-system edits are\nallowed only to add newly introduced `.cpp` files to existing DuckDB build\ntargets. Build changes that alter compiler flags, link flags, targets,\ngenerated code, install paths, external dependencies, benchmark behavior, or\nruntime paths are invalid.\n\nAllowed build-system files:\n\n```text\nCMakeLists.txt\nsrc/CMakeLists.txt\nsrc/optimizer/CMakeLists.txt\nsrc/optimizer/**/CMakeLists.txt\nsrc/planner/CMakeLists.txt\nsrc/planner/**/CMakeLists.txt\nsrc/planner/operator/CMakeLists.txt\nsrc/common/CMakeLists.txt\nsrc/common/**/CMakeLists.txt\nsrc/execution/CMakeLists.txt\nsrc/execution/operator/CMakeLists.txt\nsrc/execution/operator/join/CMakeLists.txt\nsrc/execution/operator/join/**/CMakeLists.txt\nsrc/execution/operator/filter/CMakeLists.txt\nsrc/execution/operator/filter/**/CMakeLists.txt\nsrc/execution/physical_plan/CMakeLists.txt\nsrc/execution/physical_plan/**/CMakeLists.txt\nextension_config.cmake\n```\n\nForbidden areas include benchmark files, tests, scripts, TPC-H extension code,\nthird-party code, parser/catalog/storage internals, DuckDB main/client context,\ndocumentation, examples, CI files, package manifests, and timing/scoring code.\n\nPatches may not add environment-variable reads or writes. The judge builds and\nruns both vanilla and patched DuckDB under a minimal fixed environment with no\nFrontier, Harbor, judge, secret, or submission-specific environment variables\ninherited by benchmark subprocesses.\n\nPatches also may not hard-code TPC-H table names, query numbers, benchmark\nnames, or benchmark paths in optimizer/execution code.\n\n## Resource Budget\n\nThe experimental Harbor budget is:\n\n```text\nvCPUs: 8\nmemory: 16 GiB\nstorage: 32 GiB\nbuild timeout: 7200 seconds\nquery timeout: 300 seconds\nDuckDB child process address-space limit: 12288 MiB\n```\n\nThe judge runs each build and benchmark step in a subprocess with a clean\nenvironment. DuckDB benchmark runs are configured with fixed thread, memory,\nand temporary-directory limits in the judge image to reduce the chance that a\nbad plan crashes the judge service.\n\nThe evaluator runs both vanilla and patched DuckDB with the same SQL runtime\nsettings before data generation, correctness checks, and timing:\n\n```sql\nSET threads = 1;\nSET memory_limit = '6GB';\nSET max_temp_directory_size = '2GB';\nSET temp_directory = '<judge temp directory>';\nSET preserve_insertion_order = false;\n```\n\nSubprocesses receive a minimal fixed environment with only basic execution\npaths, locale settings, an isolated home directory, an isolated temp directory,\nand an isolated ccache directory.\n", "config": "tag: systems\nruntime:\n  language: cpp\n  timeout_seconds: 10800\n  environment: \"DuckDB source patch; TPC-H shell timing; experimental judge\"\n  apt_packages:\n    - bash\n    - build-essential\n    - ca-certificates\n    - ccache\n    - cmake\n    - git\n    - ninja-build\n    - pkg-config\n    - python3\n  judge_apt_packages:\n    - bash\n    - build-essential\n    - ca-certificates\n    - ccache\n    - cmake\n    - git\n    - ninja-build\n    - pkg-config\n    - python3\n  docker:\n    # Experimental local images. Build them with\n    # 2.0/problems/duckdb_e2e_query_optimization/docker/build_images.sh before running a\n    # local Harbor trial.\n    image: frontiercs/duckdb-e2e-query-optimization-agent:experimental-v1.5.3\n    judge_image: frontiercs/duckdb-e2e-query-optimization-judge:experimental-v1.5.3\nenvironment:\n  cpus: 8\n  memory_mb: 16384\n  storage_mb: 32768\n  build_timeout_seconds: 7200\nevaluation:\n  scale_factor: 1\n  agent_scale_factors:\n    - 1\n  benchmark_repetitions: 3\n  build_timeout_seconds: 7200\n  query_timeout_seconds: 300\n  sqllogictest_timeout_seconds: 600\n  duckdb_memory_limit: \"6GB\"\n  duckdb_temp_limit: \"2GB\"\n  child_memory_mb: 12288\nsubmission:\n  kind: file\n  path: /app/solution.patch\n"}
 {"problem_id": "erdos_demo", "category": "2.0", "statement": "# Erdos Unit Distance Demo\n\n## Problem\n\nPlace exactly `N = 10` distinct points in the Euclidean plane so that the\nnumber of point pairs at Euclidean distance exactly `1` is as large as possible.\n\nThis is a tiny, visually inspectable demo version of the planar unit distance\nproblem. If your construction naturally has a different common distance, scale\nthe coordinates before returning them.\n\n## Program Interface\n\nSubmit a Python file defining one of the following:\n\n```python\ndef solve(n: int) -> list[tuple[float, float]]:\n    ...\n```\n\nor:\n\n```python\ndef generate_points(n: int) -> list[tuple[float, float]]:\n    ...\n```\n\nor:\n\n```python\nPOINTS = [(0.0, 0.0), (1.0, 0.0), ...]\n```\n\nThe returned value must contain exactly 10 two-dimensional points. No stdin is\nused.\n\n## Validity Constraints\n\nA solution is valid if:\n\n1. It returns exactly 10 points.\n2. Every coordinate is a finite real number.\n3. No two points are closer than `1e-6`.\n\nThe objective is translation-invariant. Very large coordinates are allowed as\nlong as pairwise squared distances remain finite.\n\n## Objective\n\nFor all unordered point pairs, count those whose squared Euclidean distance is\nequal to `1` within a small floating-point tolerance. Let `M` be that count.\n\nMaximize `M`.\n\n## Scoring\n\nThe score is naturally scaled to `[0, 100)`, without clipping against a fixed\ntarget. Let:\n\n```text\nbaseline = N\nX = M\n```\n\nIf the point set is invalid, or if `X <= baseline`, the score is `0`. Otherwise:\n\n```text\nscore = 100 * (X - baseline) / X\n```\n\nThis makes the simple `N`-pair baseline worth `0`. With only 10 points, the\nproblem is intended as a quick sanity check and visual demo for agent workflows.\n", "config": "tag: geometry\nruntime:\n  language: python\n  timeout_seconds: 300\n  environment: \"Python 3.11; no external packages required\"\n  docker:\n    image: ubuntu:24.04\n"}
 {"problem_id": "erdos_unit_distance", "category": "2.0", "statement": "# Erdos Unit Distance\n\n## Problem\n\nPlace exactly `N = 65536` distinct points in the Euclidean plane so that the\nnumber of point pairs at Euclidean distance exactly `1` is as large as possible.\n\nThis is a finite, executable version of the planar unit distance problem:\ngiven `n` points, maximize the number of pairs at distance exactly `1`. If your\nconstruction naturally has a different common distance, scale the coordinates\nbefore returning them.\n\n## Program Interface\n\nSubmit a Python file defining one of the following:\n\n```python\ndef solve(n: int) -> list[tuple[float, float]]:\n    ...\n```\n\nor:\n\n```python\ndef generate_points(n: int) -> list[tuple[float, float]]:\n    ...\n```\n\nor:\n\n```python\nPOINTS = [(0.0, 0.0), (1.0, 0.0), ...]\n```\n\nThe returned value must contain exactly 65536 two-dimensional points. No stdin\nis used.\n\n## Validity Constraints\n\nA solution is valid if:\n\n1. It returns exactly 65536 points.\n2. Every coordinate is a finite real number.\n3. No two points are closer than `1e-3`.\n\nThe objective is translation-invariant. Very large coordinates are allowed as\nlong as pairwise squared distances remain finite.\n\n## Objective\n\nFor all unordered point pairs, count those whose squared Euclidean distance is\nequal to `1` within a strict floating-point tolerance. Let `M` be that count.\n\nMaximize `M`.\n\n## Scoring\n\nThe score is naturally scaled to `[0, 100)`, without clipping against a fixed\ntarget. Let:\n\n```text\nbaseline = N\nX = M\n```\n\nIf the point set is invalid, or if `X <= baseline`, the score is `0`. Otherwise\nthe raw score is:\n\n```text\nraw_score = 100 * (X - baseline) / X\n```\n\nThe reported score applies a cubic scale:\n\n```text\nscore = 100 * (raw_score / 100)^3\n```\n\nThis makes the simple `N`-pair baseline worth `0`, rewards every improvement\nabove the baseline, and keeps high-scoring constructions from saturating the\nbenchmark too quickly. The bounded and unbounded score fields both report this\ncubic-scaled score; evaluator messages also include `raw_score` for reference.\n", "config": "tag: geometry\nruntime:\n  language: python\n  timeout_seconds: 10800\n  environment: \"Python 3.11; no external packages required\"\n  docker:\n    image: ubuntu:24.04\n"}